diff --git a/controllers/elbv2/targetgroupbinding_controller.go b/controllers/elbv2/targetgroupbinding_controller.go index 88c1561eee..36f898b587 100644 --- a/controllers/elbv2/targetgroupbinding_controller.go +++ b/controllers/elbv2/targetgroupbinding_controller.go @@ -21,7 +21,7 @@ import ( "fmt" "time" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" discv1 "k8s.io/api/discovery/v1" @@ -138,7 +138,7 @@ func (r *targetGroupBindingReconciler) cleanupTargetGroupBinding(ctx context.Con } func (r *targetGroupBindingReconciler) updateTargetGroupBindingStatus(ctx context.Context, tgb *elbv2api.TargetGroupBinding) error { - if aws.Int64Value(tgb.Status.ObservedGeneration) == tgb.Generation { + if aws.ToInt64(tgb.Status.ObservedGeneration) == tgb.Generation { return nil } tgbOld := tgb.DeepCopy() diff --git a/go.mod b/go.mod index 5a1e5fdc6e..e07b1a8cbc 100644 --- a/go.mod +++ b/go.mod @@ -1,9 +1,19 @@ module sigs.k8s.io/aws-load-balancer-controller -go 1.22.3 +go 1.22.4 require ( - github.com/aws/aws-sdk-go v1.50.8 + github.com/aws/aws-sdk-go-v2 v1.30.3 + github.com/aws/aws-sdk-go-v2/config v1.27.27 + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11 + github.com/aws/aws-sdk-go-v2/service/acm v1.28.4 + github.com/aws/aws-sdk-go-v2/service/ec2 v1.173.0 + github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0 + github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.23.3 + github.com/aws/aws-sdk-go-v2/service/shield v1.27.3 + github.com/aws/aws-sdk-go-v2/service/wafregional v1.23.3 + github.com/aws/aws-sdk-go-v2/service/wafv2 v1.51.4 + github.com/aws/smithy-go v1.20.3 github.com/evanphx/json-patch v5.7.0+incompatible github.com/gavv/httpexpect/v2 v2.9.0 github.com/go-logr/logr v1.4.1 @@ -41,6 +51,15 @@ require ( github.com/ajg/form v1.5.1 // indirect github.com/andybalholm/brotli v1.0.4 // indirect github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.17.27 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.22.4 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.30.3 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/chai2010/gettext-go v1.0.2 // indirect diff --git a/go.sum b/go.sum index 1861c7278e..5de579e332 100644 --- a/go.sum +++ b/go.sum @@ -36,8 +36,46 @@ github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5 h1:0CwZNZbxp69SHPd github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5/go.mod h1:wHh0iHkYZB8zMSxRWpUBQtwG5a7fFgvEO+odwuTv2gs= github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535 h1:4daAzAu0S6Vi7/lbWECcX0j45yZReDZ56BQsrVBOEEY= github.com/asaskevich/govalidator v0.0.0-20200428143746-21a406dcc535/go.mod h1:oGkLhpf+kjZl6xBf758TQhh5XrAeiJv/7FRz/2spLIg= -github.com/aws/aws-sdk-go v1.50.8 h1:gY0WoOW+/Wz6XmYSgDH9ge3wnAevYDSQWPxxJvqAkP4= -github.com/aws/aws-sdk-go v1.50.8/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk= +github.com/aws/aws-sdk-go-v2 v1.30.3 h1:jUeBtG0Ih+ZIFH0F4UkmL9w3cSpaMv9tYYDbzILP8dY= +github.com/aws/aws-sdk-go-v2 v1.30.3/go.mod h1:nIQjQVp5sfpQcTc9mPSr1B0PaWK5ByX9MOoDadSN4lc= +github.com/aws/aws-sdk-go-v2/config v1.27.27 h1:HdqgGt1OAP0HkEDDShEl0oSYa9ZZBSOmKpdpsDMdO90= +github.com/aws/aws-sdk-go-v2/config v1.27.27/go.mod h1:MVYamCg76dFNINkZFu4n4RjDixhVr51HLj4ErWzrVwg= +github.com/aws/aws-sdk-go-v2/credentials v1.17.27 h1:2raNba6gr2IfA0eqqiP2XiQ0UVOpGPgDSi0I9iAP+UI= +github.com/aws/aws-sdk-go-v2/credentials v1.17.27/go.mod h1:gniiwbGahQByxan6YjQUMcW4Aov6bLC3m+evgcoN4r4= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11 h1:KreluoV8FZDEtI6Co2xuNk/UqI9iwMrOx/87PBNIKqw= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.16.11/go.mod h1:SeSUYBLsMYFoRvHE0Tjvn7kbxaUhl75CJi1sbfhMxkU= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15 h1:SoNJ4RlFEQEbtDcCEt+QG56MY4fm4W8rYirAmq+/DdU= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.15/go.mod h1:U9ke74k1n2bf+RIgoX1SXFed1HLs51OgUSs+Ph0KJP8= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15 h1:C6WHdGnTDIYETAm5iErQUiVNsclNx9qbJVPIt03B6bI= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.15/go.mod h1:ZQLZqhcu+JhSrA9/NXRm8SkDvsycE+JkV3WGY41e+IM= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0 h1:hT8rVHwugYE2lEfdFE0QWVo81lF7jMrYJVDWI+f+VxU= +github.com/aws/aws-sdk-go-v2/internal/ini v1.8.0/go.mod h1:8tu/lYfQfFe6IGnaOdrpVgEL2IrrDOf6/m9RQum4NkY= +github.com/aws/aws-sdk-go-v2/service/acm v1.28.4 h1:wiW1Y6/1lysA0eJZRq0I53YYKuV9MNAzL15z2eZRlEE= +github.com/aws/aws-sdk-go-v2/service/acm v1.28.4/go.mod h1:bzjymHHRhexkSMIvUHMpKydo9U82bmqQ5ru0IzYM8m8= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.173.0 h1:ta62lid9JkIpKZtZZXSj6rP2AqY5x1qYGq53ffxqD9Q= +github.com/aws/aws-sdk-go-v2/service/ec2 v1.173.0/go.mod h1:o6QDjdVKpP5EF0dp/VlvqckzuSDATr1rLdHt3A5m0YY= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0 h1:8rDRtPOu3ax8jEctw7G926JQlnFdhZZA4KJzQ+4ks3Q= +github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2 v1.34.0/go.mod h1:L5bVuO4PeXuDuMYZfL3IW69E6mz6PDCYpp6IKDlcLMA= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3 h1:dT3MqvGhSoaIhRseqw2I0yH81l7wiR2vjs57O51EAm8= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.11.3/go.mod h1:GlAeCkHwugxdHaueRr4nhPuY+WW+gR8UjlcqzPr1SPI= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17 h1:HGErhhrxZlQ044RiM+WdoZxp0p+EGM62y3L6pwA4olE= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.11.17/go.mod h1:RkZEx4l0EHYDJpWppMJ3nD9wZJAa8/0lq9aVC+r2UII= +github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.23.3 h1:ByynKMsGZGmpUpnQ99y+lS7VxZrNt3mdagCnHd011Kk= +github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi v1.23.3/go.mod h1:ZR4h87npHPuVQ2SEeoWMe+CO/HcS9g2iYMLnT5HawW8= +github.com/aws/aws-sdk-go-v2/service/shield v1.27.3 h1:SfjI6FuphzspGPvcRD8hjMD6wLUAE6vtJLGrui19j2s= +github.com/aws/aws-sdk-go-v2/service/shield v1.27.3/go.mod h1:JpxjPa91y1hRb3G8xxzhOQFcK/r90it41jA/hD0q+Gg= +github.com/aws/aws-sdk-go-v2/service/sso v1.22.4 h1:BXx0ZIxvrJdSgSvKTZ+yRBeSqqgPM89VPlulEcl37tM= +github.com/aws/aws-sdk-go-v2/service/sso v1.22.4/go.mod h1:ooyCOXjvJEsUw7x+ZDHeISPMhtwI3ZCB7ggFMcFfWLU= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4 h1:yiwVzJW2ZxZTurVbYWA7QOrAaCYQR72t0wrSBfoesUE= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.26.4/go.mod h1:0oxfLkpz3rQ/CHlx5hB7H69YUpFiI1tql6Q6Ne+1bCw= +github.com/aws/aws-sdk-go-v2/service/sts v1.30.3 h1:ZsDKRLXGWHk8WdtyYMoGNO7bTudrvuKpDKgMVRlepGE= +github.com/aws/aws-sdk-go-v2/service/sts v1.30.3/go.mod h1:zwySh8fpFyXp9yOr/KVzxOl8SRqgf/IDw5aUt9UKFcQ= +github.com/aws/aws-sdk-go-v2/service/wafregional v1.23.3 h1:7dr6En0/6KRFoz8VmnYks9dVvL+tkL5RjRrxqGzr1zI= +github.com/aws/aws-sdk-go-v2/service/wafregional v1.23.3/go.mod h1:24TtlRsv4LKAE3VnRJQhpatr8cpX0yj8NSzg8/lxOCw= +github.com/aws/aws-sdk-go-v2/service/wafv2 v1.51.4 h1:1khBA5uryBRJoCb4G2iR5RT06BkfPEjjDCHAiRb8P3Q= +github.com/aws/aws-sdk-go-v2/service/wafv2 v1.51.4/go.mod h1:QpFImaPGKNwa+MiZ+oo6LbV1PVQBapc0CnrAMRScoxM= +github.com/aws/smithy-go v1.20.3 h1:ryHwveWzPV5BIof6fyDvor6V3iUL7nTfiTKXHiW05nE= +github.com/aws/smithy-go v1.20.3/go.mod h1:krry+ya/rV9RDcV/Q16kpu6ypI4K2czasz0NC3qS14E= 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 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= diff --git a/pkg/annotations/parser.go b/pkg/annotations/parser.go index 3d6e231b14..b617543b76 100644 --- a/pkg/annotations/parser.go +++ b/pkg/annotations/parser.go @@ -44,6 +44,10 @@ type Parser interface { // returns whether annotation exists and parser error if any. ParseInt64Annotation(annotation string, value *int64, annotations map[string]string, opts ...ParseOption) (bool, error) + // ParseInt32Annotation parses annotation into int32 value, + // returns whether annotation exists and parser error if any. + ParseInt32Annotation(annotation string, value *int32, annotations map[string]string, opts ...ParseOption) (bool, error) + // ParseStringSliceAnnotation parses comma separated values from the annotation into string slice // returns true if the annotation exists ParseStringSliceAnnotation(annotation string, value *[]string, annotations map[string]string, opts ...ParseOption) bool @@ -106,6 +110,20 @@ func (p *suffixAnnotationParser) ParseInt64Annotation(annotation string, value * return true, nil } +func (p *suffixAnnotationParser) ParseInt32Annotation(annotation string, value *int32, annotations map[string]string, opts ...ParseOption) (bool, error) { + raw := "" + exists, matchedKey := p.parseStringAnnotation(annotation, &raw, annotations, opts...) + if !exists { + return false, nil + } + i, err := strconv.ParseInt(raw, 10, 64) + if err != nil { + return true, errors.Wrapf(err, "failed to parse int32 annotation, %v: %v", matchedKey, raw) + } + *value = int32(i) + return true, nil +} + func (p *suffixAnnotationParser) ParseStringSliceAnnotation(annotation string, value *[]string, annotations map[string]string, opts ...ParseOption) bool { raw := "" if exists, _ := p.parseStringAnnotation(annotation, &raw, annotations, opts...); !exists { diff --git a/pkg/aws/cloud.go b/pkg/aws/cloud.go index faba5cec47..99fa4f5e52 100644 --- a/pkg/aws/cloud.go +++ b/pkg/aws/cloud.go @@ -3,24 +3,27 @@ package aws import ( "context" "fmt" + awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware" + "github.com/aws/aws-sdk-go-v2/config" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + smithymiddleware "github.com/aws/smithy-go/middleware" "net" "os" + "sigs.k8s.io/aws-load-balancer-controller/pkg/version" "strings" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/endpoints" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" + "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/pkg/errors" "github.com/prometheus/client_golang/prometheus" amerrors "k8s.io/apimachinery/pkg/util/errors" - epresolver "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/endpoints" - "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/metrics" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" - "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/throttle" ) +const userAgent = "elbv2.k8s.aws" + type Cloud interface { // EC2 provides API to AWS EC2 EC2() services.EC2 @@ -64,17 +67,18 @@ func NewCloud(cfg CloudConfig, metricsRegisterer prometheus.Registerer, logger l } } } - - endpointsResolver := epresolver.NewResolver(cfg.AWSEndpoints) - metadataCFG := aws.NewConfig().WithEndpointResolver(endpointsResolver) - opts := session.Options{} - opts.Config.MergeIn(metadataCFG) + var ec2IMDSEndpointMode imds.EndpointModeState if !hasIPv4 { - opts.EC2IMDSEndpointMode = endpoints.EC2IMDSEndpointModeStateIPv6 + ec2IMDSEndpointMode = imds.EndpointModeStateIPv6 + } else { + ec2IMDSEndpointMode = imds.EndpointModeStateIPv4 } - metadataSess := session.Must(session.NewSessionWithOptions(opts)) - metadata := services.NewEC2Metadata(metadataSess) + ec2MetadataCfg, err := config.LoadDefaultConfig(context.TODO(), + config.WithRetryMaxAttempts(cfg.MaxRetries), + config.WithEC2IMDSEndpointMode(ec2IMDSEndpointMode), + ) + ec2Metadata := services.NewEC2Metadata(ec2MetadataCfg) if len(cfg.Region) == 0 { region := os.Getenv("AWS_DEFAULT_REGION") @@ -84,37 +88,39 @@ func NewCloud(cfg CloudConfig, metricsRegisterer prometheus.Registerer, logger l if region == "" { err := (error)(nil) - region, err = metadata.Region() + region, err = ec2Metadata.Region() if err != nil { return nil, errors.Wrap(err, "failed to introspect region from EC2Metadata, specify --aws-region instead if EC2Metadata is unavailable") } } cfg.Region = region } - awsCFG := aws.NewConfig().WithRegion(cfg.Region).WithSTSRegionalEndpoint(endpoints.RegionalSTSEndpoint).WithMaxRetries(cfg.MaxRetries).WithEndpointResolver(endpointsResolver) - opts = session.Options{} - opts.Config.MergeIn(awsCFG) - if !hasIPv4 { - opts.EC2IMDSEndpointMode = endpoints.EC2IMDSEndpointModeStateIPv6 - } - sess := session.Must(session.NewSessionWithOptions(opts)) - injectUserAgent(&sess.Handlers) - - if cfg.ThrottleConfig != nil { - throttler := throttle.NewThrottler(cfg.ThrottleConfig) - throttler.InjectHandlers(&sess.Handlers) - } - if metricsRegisterer != nil { - metricsCollector, err := metrics.NewCollector(metricsRegisterer) - if err != nil { - return nil, errors.Wrapf(err, "failed to initialize sdk metrics collector") - } - metricsCollector.InjectHandlers(&sess.Handlers) - } - - ec2Service := services.NewEC2(sess) - - vpcID, err := getVpcID(cfg, ec2Service, metadata, logger) + awsConfig, err := config.LoadDefaultConfig(context.TODO(), + config.WithRegion(cfg.Region), + config.WithRetryMaxAttempts(cfg.MaxRetries), + config.WithEC2IMDSEndpointMode(ec2IMDSEndpointMode), + config.WithAPIOptions([]func(stack *smithymiddleware.Stack) error{ + awsmiddleware.AddUserAgentKeyValue(userAgent, version.GitVersion), + }), + ) + + //TODO: ADD metric collection and throttle configuration later + //if cfg.ThrottleConfig != nil { + // throttler := throttle.NewThrottler(cfg.ThrottleConfig) + // throttler.InjectHandlers(&sess.Handlers) + //} + + //if metricsRegisterer != nil { + // metricsCollector, err := metrics.NewCollector(metricsRegisterer) + // if err != nil { + // return nil, errors.Wrapf(err, "failed to initialize sdk metrics collector") + // } + // awsConfig.APIOptions = append(awsConfig.APIOptions, metricsCollector.CollectAPICallMetricMiddleware()) + //} + + ec2Service := services.NewEC2(awsConfig) + + vpcID, err := getVpcID(cfg, ec2Service, ec2Metadata, logger) if err != nil { return nil, errors.Wrap(err, "failed to get VPC ID") } @@ -122,16 +128,16 @@ func NewCloud(cfg CloudConfig, metricsRegisterer prometheus.Registerer, logger l return &defaultCloud{ cfg: cfg, ec2: ec2Service, - elbv2: services.NewELBV2(sess), - acm: services.NewACM(sess), - wafv2: services.NewWAFv2(sess), - wafRegional: services.NewWAFRegional(sess, cfg.Region), - shield: services.NewShield(sess), - rgt: services.NewRGT(sess), + elbv2: services.NewELBV2(awsConfig), + acm: services.NewACM(awsConfig), + wafv2: services.NewWAFv2(awsConfig), + wafRegional: services.NewWAFRegional(awsConfig, cfg.Region), + shield: services.NewShield(awsConfig), //done + rgt: services.NewRGT(awsConfig), }, nil } -func getVpcID(cfg CloudConfig, ec2Service services.EC2, metadata services.EC2Metadata, logger logr.Logger) (string, error) { +func getVpcID(cfg CloudConfig, ec2Service services.EC2, ec2Metadata services.EC2Metadata, logger logr.Logger) (string, error) { if cfg.VpcID != "" { logger.V(1).Info("vpcid is specified using flag --aws-vpc-id, controller will use the value", "vpc: ", cfg.VpcID) @@ -142,12 +148,12 @@ func getVpcID(cfg CloudConfig, ec2Service services.EC2, metadata services.EC2Met return inferVPCIDFromTags(ec2Service, cfg.VpcNameTagKey, cfg.VpcTags[cfg.VpcNameTagKey]) } - return inferVPCID(metadata, ec2Service) + return inferVPCID(ec2Metadata, ec2Service) } -func inferVPCID(metadata services.EC2Metadata, ec2Service services.EC2) (string, error) { +func inferVPCID(ec2Metadata services.EC2Metadata, ec2Service services.EC2) (string, error) { var errList []error - vpcId, err := metadata.VpcID() + vpcId, err := ec2Metadata.VpcID() if err == nil { return vpcId, nil } else { @@ -156,8 +162,8 @@ func inferVPCID(metadata services.EC2Metadata, ec2Service services.EC2) (string, nodeName := os.Getenv("NODENAME") if strings.HasPrefix(nodeName, "i-") { - output, err := ec2Service.DescribeInstances(&ec2.DescribeInstancesInput{ - InstanceIds: []*string{&nodeName}, + output, err := ec2Service.DescribeInstancesWithContext(context.Background(), &ec2.DescribeInstancesInput{ + InstanceIds: []string{nodeName}, }) if err != nil { errList = append(errList, errors.Wrapf(err, "failed to describe instance %q", nodeName)) @@ -183,10 +189,10 @@ func inferVPCID(metadata services.EC2Metadata, ec2Service services.EC2) (string, func inferVPCIDFromTags(ec2Service services.EC2, VpcNameTagKey string, VpcNameTagValue string) (string, error) { vpcs, err := ec2Service.DescribeVPCsAsList(context.Background(), &ec2.DescribeVpcsInput{ - Filters: []*ec2.Filter{ + Filters: []ec2types.Filter{ { Name: aws.String("tag:" + VpcNameTagKey), - Values: []*string{aws.String(VpcNameTagValue)}, + Values: []string{VpcNameTagValue}, }, }, }) @@ -208,9 +214,8 @@ var _ Cloud = &defaultCloud{} type defaultCloud struct { cfg CloudConfig - ec2 services.EC2 - elbv2 services.ELBV2 - + ec2 services.EC2 + elbv2 services.ELBV2 acm services.ACM wafv2 services.WAFv2 wafRegional services.WAFRegional diff --git a/pkg/aws/endpoints/resolver.go b/pkg/aws/endpoints/resolver.go deleted file mode 100644 index d66b3a94ab..0000000000 --- a/pkg/aws/endpoints/resolver.go +++ /dev/null @@ -1,30 +0,0 @@ -package endpoints - -import ( - awsendpoints "github.com/aws/aws-sdk-go/aws/endpoints" -) - -func NewResolver(configuration map[string]string) *resolver { - return &resolver{ - configuration: configuration, - } -} - -var _ awsendpoints.Resolver = &resolver{} - -// resolver is an AWS endpoints.Resolver that allows to customize AWS API endpoints. -// It can be configured using the following format "${AWSServiceID}=${URL}" -// e.g. "ec2=https://ec2.domain.com,elasticloadbalancing=https://elbv2.domain.com" -type resolver struct { - configuration map[string]string -} - -func (c *resolver) EndpointFor(service, region string, opts ...func(*awsendpoints.Options)) (awsendpoints.ResolvedEndpoint, error) { - customEndpoint := c.configuration[service] - if len(customEndpoint) != 0 { - return awsendpoints.ResolvedEndpoint{ - URL: customEndpoint, - }, nil - } - return awsendpoints.DefaultResolver().EndpointFor(service, region, opts...) -} diff --git a/pkg/aws/endpoints/resolver_test.go b/pkg/aws/endpoints/resolver_test.go deleted file mode 100644 index db6fcd32a3..0000000000 --- a/pkg/aws/endpoints/resolver_test.go +++ /dev/null @@ -1,66 +0,0 @@ -package endpoints - -import ( - "testing" - - awsendpoints "github.com/aws/aws-sdk-go/aws/endpoints" - "github.com/stretchr/testify/assert" -) - -func TestAWSEndpointResolver_EndpointFor(t *testing.T) { - configuration := map[string]string{ - awsendpoints.Ec2ServiceID: "https://ec2.domain.com", - awsendpoints.ElasticloadbalancingServiceID: "https://elbv2.domain.com", - } - c := &resolver{ - configuration: configuration, - } - - testRegion := "region" - - type args struct { - val string - } - - tests := []struct { - name string - args args - want *awsendpoints.ResolvedEndpoint - wantErr error - }{ - { - name: "when custom endpoint is configured", - args: args{ - val: awsendpoints.Ec2ServiceID, - }, - want: &awsendpoints.ResolvedEndpoint{ - URL: configuration[awsendpoints.Ec2ServiceID], - }, - }, - { - name: "when custom endpoint is unconfigured", - args: args{ - val: awsendpoints.WafServiceID, - }, - want: nil, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - res, err := c.EndpointFor(tt.args.val, testRegion) - if tt.wantErr != nil { - assert.EqualError(t, err, tt.wantErr.Error()) - } else { - assert.NoError(t, err) - if tt.want != nil { - assert.Equal(t, *tt.want, res) - } else { - defaultEndpoint, err := awsendpoints.DefaultResolver().EndpointFor(tt.args.val, testRegion) - assert.NoError(t, err) - assert.Equal(t, defaultEndpoint, res) - } - } - }) - } -} diff --git a/pkg/aws/metrics/collector.go b/pkg/aws/metrics/collector.go index 0a6db8ca82..8cb552461b 100644 --- a/pkg/aws/metrics/collector.go +++ b/pkg/aws/metrics/collector.go @@ -1,11 +1,7 @@ package metrics import ( - "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/aws/request" "github.com/prometheus/client_golang/prometheus" - "strconv" - "time" ) const ( @@ -27,84 +23,105 @@ func NewCollector(registerer prometheus.Registerer) (*collector, error) { }, nil } -func (c *collector) InjectHandlers(handlers *request.Handlers) { - handlers.CompleteAttempt.PushFrontNamed(request.NamedHandler{ - Name: sdkHandlerCollectAPIRequestMetric, - Fn: c.collectAPIRequestMetric, - }) - handlers.Complete.PushFrontNamed(request.NamedHandler{ - Name: sdkHandlerCollectAPICallMetric, - Fn: c.collectAPICallMetric, - }) -} - -func (c *collector) collectAPIRequestMetric(r *request.Request) { - service := r.ClientInfo.ServiceID - operation := r.Operation.Name - statusCode := statusCodeForRequest(r) - errorCode := errorCodeForRequest(r) - duration := time.Since(r.AttemptTime) - - c.instruments.apiRequestsTotal.With(map[string]string{ - labelService: service, - labelOperation: operation, - labelStatusCode: statusCode, - labelErrorCode: errorCode, - }).Inc() - c.instruments.apiRequestDurationSecond.With(map[string]string{ - labelService: service, - labelOperation: operation, - }).Observe(duration.Seconds()) -} +// TODO : WIP Migrate metric collection +//func (c *collector) InjectHandlers(cfg aws.Config) { +// handlers.CompleteAttempt.PushFrontNamed(request.NamedHandler{ +// Name: sdkHandlerCollectAPIRequestMetric, +// Fn: c.collectAPIRequestMetric, +// }) +// handlers.Complete.PushFrontNamed(request.NamedHandler{ +// Name: sdkHandlerCollectAPICallMetric, +// Fn: c.collectAPICallMetric, +// }) +//} -func (c *collector) collectAPICallMetric(r *request.Request) { - service := r.ClientInfo.ServiceID - operation := r.Operation.Name - statusCode := statusCodeForRequest(r) - errorCode := errorCodeForRequest(r) - duration := time.Since(r.Time) - - c.instruments.apiCallsTotal.With(map[string]string{ - labelService: service, - labelOperation: operation, - labelStatusCode: statusCode, - labelErrorCode: errorCode, - }).Inc() - c.instruments.apiCallDurationSeconds.With(map[string]string{ - labelService: service, - labelOperation: operation, - }).Observe(duration.Seconds()) - c.instruments.apiCallRetries.With(map[string]string{ - labelService: service, - labelOperation: operation, - }).Observe(float64(r.RetryCount)) -} - -// statusCodeForRequest returns the http status code for request. -// if there is no http response, returns "0". -func statusCodeForRequest(r *request.Request) string { - if r.HTTPResponse != nil { - return strconv.Itoa(r.HTTPResponse.StatusCode) - } - return "0" -} - -// errorCodeForRequest returns the error code for request. -// if no error happened, returns "". -func errorCodeForRequest(r *request.Request) string { - if r.Error != nil { - if awserr, ok := r.Error.(awserr.Error); ok { - return awserr.Code() - } - return "internal" - } - return "" -} - -// operationForRequest returns the operation for request. -func operationForRequest(r *request.Request) string { - if r.Operation != nil { - return r.Operation.Name - } - return "?" -} +//func (c *collector) CollectAPICallMetricMiddleware() func(*smithymiddleware.Stack) error { +// return func(stack *smithymiddleware.Stack) error { +// return stack.Finalize.Add(smithymiddleware.FinalizeMiddlewareFunc("CollectAPICallMetricMiddleware", func(ctx context.Context, input smithymiddleware.FinalizeInput, next smithymiddleware.FinalizeHandler) (output smithymiddleware.FinalizeOutput, metadata smithymiddleware.Metadata, err error) { +// start := time.Now() +// output, metadata, err = next.HandleFinalize(ctx, input) +// service := awsmiddleware.GetServiceID(ctx) +// operation := awsmiddleware.GetOperationName(ctx) +// response, ok := output.Result.(*smithyhttp.Response) +// if !ok { +// return ok +// } +// statusCode := response.StatusCode +// errorCode := response +// duration := time.Since(r.Time) +// +// }), smithymiddleware.Before) +// } +// } +//} +// +//func (c *collector) collectAPIRequestMetric(r *request.Request) { +// service := r.ClientInfo.ServiceID +// operation := r.Operation.Name +// statusCode := statusCodeForRequest(r) +// errorCode := errorCodeForRequest(r) +// duration := time.Since(r.AttemptTime) +// +// c.instruments.apiRequestsTotal.With(map[string]string{ +// labelService: service, +// labelOperation: operation, +// labelStatusCode: statusCode, +// labelErrorCode: errorCode, +// }).Inc() +// c.instruments.apiRequestDurationSecond.With(map[string]string{ +// labelService: service, +// labelOperation: operation, +// }).Observe(duration.Seconds()) +//} +// +//func (c *collector) collectAPICallMetric(r *request.Request) { +// service := r.ClientInfo.ServiceID +// operation := r.Operation.Name +// statusCode := statusCodeForRequest(r) +// errorCode := errorCodeForRequest(r) +// duration := time.Since(r.Time) +// +// c.instruments.apiCallsTotal.With(map[string]string{ +// labelService: service, +// labelOperation: operation, +// labelStatusCode: statusCode, +// labelErrorCode: errorCode, +// }).Inc() +// c.instruments.apiCallDurationSeconds.With(map[string]string{ +// labelService: service, +// labelOperation: operation, +// }).Observe(duration.Seconds()) +// c.instruments.apiCallRetries.With(map[string]string{ +// labelService: service, +// labelOperation: operation, +// }).Observe(float64(r.RetryCount)) +//} +// +//// statusCodeForRequest returns the http status code for request. +//// if there is no http response, returns "0". +//func statusCodeForRequest(r *request.Request) string { +// if r.HTTPResponse != nil { +// return strconv.Itoa(r.HTTPResponse.StatusCode) +// } +// return "0" +//} +// +//// errorCodeForRequest returns the error code for request. +//// if no error happened, returns "". +//func errorCodeForRequest(r *request.Request) string { +// if r.Error != nil { +// if awserr, ok := r.Error.(awserr.Error); ok { +// return awserr.Code() +// } +// return "internal" +// } +// return "" +//} +// +//// operationForRequest returns the operation for request. +//func operationForRequest(r *request.Request) string { +// if r.Operation != nil { +// return r.Operation.Name +// } +// return "?" +//} diff --git a/pkg/aws/metrics/collector_test.go b/pkg/aws/metrics/collector_test.go index 921a18ba6a..e25ced51e1 100644 --- a/pkg/aws/metrics/collector_test.go +++ b/pkg/aws/metrics/collector_test.go @@ -1,125 +1,126 @@ package metrics -import ( - "errors" - "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/aws/request" - "github.com/stretchr/testify/assert" - "net/http" - "testing" -) - -func Test_statusCodeForRequest(t *testing.T) { - type args struct { - r *request.Request - } - tests := []struct { - name string - args args - want string - }{ - { - name: "requests without http response", - args: args{ - r: &request.Request{}, - }, - want: "0", - }, - { - name: "requests with http response", - args: args{ - r: &request.Request{ - HTTPResponse: &http.Response{ - StatusCode: 200, - }, - }, - }, - want: "200", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := statusCodeForRequest(tt.args.r) - assert.Equal(t, tt.want, got) - }) - } -} - -func Test_errorCodeForRequest(t *testing.T) { - type args struct { - r *request.Request - } - tests := []struct { - name string - args args - want string - }{ - { - name: "requests without error", - args: args{ - r: &request.Request{}, - }, - want: "", - }, - { - name: "requests with internal error", - args: args{ - r: &request.Request{ - Error: errors.New("oops, some internal error"), - }, - }, - want: "internal", - }, - { - name: "requests with aws error", - args: args{ - r: &request.Request{ - Error: awserr.New("NotFoundException", "", nil), - }, - }, - want: "NotFoundException", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := errorCodeForRequest(tt.args.r) - assert.Equal(t, tt.want, got) - }) - } -} - -func Test_operationForRequest(t *testing.T) { - type args struct { - r *request.Request - } - tests := []struct { - name string - args args - want string - }{ - { - name: "requests without operation", - args: args{ - r: &request.Request{}, - }, - want: "?", - }, - { - name: "requests with operation", - args: args{ - r: &request.Request{ - Operation: &request.Operation{ - Name: "DescribeMesh", - }, - }, - }, - want: "DescribeMesh", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - got := operationForRequest(tt.args.r) - assert.Equal(t, tt.want, got) - }) - } -} +// TODO: WIP Migrate metric collection +//import ( +// "errors" +// "github.com/stretchr/testify/assert" +// "net/http" +// "testing" +//) +// +//func Test_statusCodeForRequest(t *testing.T) { +// type args struct { +// r *request.Request +// } +// tests := []struct { +// name string +// args args +// want string +// }{ +// { +// name: "requests without http response", +// args: args{ +// r: &request.Request{}, +// }, +// want: "0", +// }, +// { +// name: "requests with http response", +// args: args{ +// r: &request.Request{ +// HTTPResponse: &http.Response{ +// StatusCode: 200, +// }, +// }, +// }, +// want: "200", +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// got := statusCodeForRequest(tt.args.r) +// assert.Equal(t, tt.want, got) +// }) +// } +//} +// +//func Test_errorCodeForRequest(t *testing.T) { +// type args struct { +// r *request.Request +// } +// tests := []struct { +// name string +// args args +// want string +// }{ +// { +// name: "requests without error", +// args: args{ +// r: &request.Request{}, +// }, +// want: "", +// }, +// { +// name: "requests with internal error", +// args: args{ +// r: &request.Request{ +// Error: errors.New("oops, some internal error"), +// }, +// }, +// want: "internal", +// }, +// { +// name: "requests with aws error", +// args: args{ +// r: &request.Request{ +// Error: &smithy.GenericAPIError{Code: "NotFoundException", Message: ""}, +// }, +// }, +// want: "NotFoundException", +// }, +// }, +// for _, tt := range tests{ +// t.Run(tt.name, func (t *testing.T){ +// got := errorCodeForRequest(tt.args.r) +// assert.Equal(t, tt.want, got) +// }) +// } +// } +// +// func +// Test_operationForRequest(t * testing.T) +// { +// type args struct { +// r *request.Request +// } +// tests := []struct { +// name string +// args args +// want string +// }{ +// { +// name: "requests without operation", +// args: args{ +// r: &request.Request{}, +// }, +// want: "?", +// }, +// { +// name: "requests with operation", +// args: args{ +// r: &request.Request{ +// Operation: &request.Operation{ +// Name: "DescribeMesh", +// }, +// }, +// }, +// want: "DescribeMesh", +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// got := operationForRequest(tt.args.r) +// assert.Equal(t, tt.want, got) +// }) +// } +// } diff --git a/pkg/aws/retry/custom_retryer.go b/pkg/aws/retry/custom_retryer.go deleted file mode 100644 index 515f19252d..0000000000 --- a/pkg/aws/retry/custom_retryer.go +++ /dev/null @@ -1,24 +0,0 @@ -package retry - -import ( - "github.com/aws/aws-sdk-go/aws/request" -) - -// request option that configures a custom maxRetries. -func WithMaxRetries(maxRetries int) request.Option { - return func(r *request.Request) { - r.Retryer = &CustomRetryer{ - Retryer: r.Retryer, - numMaxRetries: maxRetries, - } - } -} - -type CustomRetryer struct { - request.Retryer - numMaxRetries int -} - -func (c *CustomRetryer) MaxRetries() int { - return c.numMaxRetries -} diff --git a/pkg/aws/retry/custom_retryer_test.go b/pkg/aws/retry/custom_retryer_test.go deleted file mode 100644 index 7517b7cf58..0000000000 --- a/pkg/aws/retry/custom_retryer_test.go +++ /dev/null @@ -1,35 +0,0 @@ -package retry - -import ( - "github.com/aws/aws-sdk-go/aws/request" - "github.com/stretchr/testify/assert" - "testing" -) - -func TestWithMaxRetries(t *testing.T) { - type args struct { - maxRetries int - } - tests := []struct { - name string - args args - wantMaxRetries int - }{ - { - name: "normal case", - args: args{ - maxRetries: 10, - }, - wantMaxRetries: 10, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - option := WithMaxRetries(tt.args.maxRetries) - r := &request.Request{} - option(r) - gotMaxRetries := r.MaxRetries() - assert.Equal(t, tt.wantMaxRetries, gotMaxRetries) - }) - } -} diff --git a/pkg/aws/services/acm.go b/pkg/aws/services/acm.go index 5aae9f0891..e27bcfc6b1 100644 --- a/pkg/aws/services/acm.go +++ b/pkg/aws/services/acm.go @@ -2,36 +2,41 @@ package services import ( "context" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/acm" - "github.com/aws/aws-sdk-go/service/acm/acmiface" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/acm" + "github.com/aws/aws-sdk-go-v2/service/acm/types" ) type ACM interface { - acmiface.ACMAPI - // wrapper to ListCertificatesPagesWithContext API, which aggregates paged results into list. - ListCertificatesAsList(ctx context.Context, input *acm.ListCertificatesInput) ([]*acm.CertificateSummary, error) + ListCertificatesAsList(ctx context.Context, input *acm.ListCertificatesInput) ([]types.CertificateSummary, error) + DescribeCertificateWithContext(ctx context.Context, req *acm.DescribeCertificateInput) (*acm.DescribeCertificateOutput, error) } // NewACM constructs new ACM implementation. -func NewACM(session *session.Session) *defaultACM { - return &defaultACM{ - ACMAPI: acm.New(session), +func NewACM(cfg aws.Config) ACM { + return &acmClient{ + acmClient: acm.NewFromConfig(cfg), } } -type defaultACM struct { - acmiface.ACMAPI +type acmClient struct { + acmClient *acm.Client } -func (c *defaultACM) ListCertificatesAsList(ctx context.Context, input *acm.ListCertificatesInput) ([]*acm.CertificateSummary, error) { - var result []*acm.CertificateSummary - if err := c.ListCertificatesPagesWithContext(ctx, input, func(output *acm.ListCertificatesOutput, _ bool) bool { +func (c *acmClient) ListCertificatesAsList(ctx context.Context, input *acm.ListCertificatesInput) ([]types.CertificateSummary, error) { + var result []types.CertificateSummary + paginator := acm.NewListCertificatesPaginator(c.acmClient, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } result = append(result, output.CertificateSummaryList...) - return true - }); err != nil { - return nil, err } return result, nil } + +func (c *acmClient) DescribeCertificateWithContext(ctx context.Context, input *acm.DescribeCertificateInput) (*acm.DescribeCertificateOutput, error) { + return c.acmClient.DescribeCertificate(ctx, input) +} diff --git a/pkg/aws/services/acm_mocks.go b/pkg/aws/services/acm_mocks.go new file mode 100644 index 0000000000..874582e874 --- /dev/null +++ b/pkg/aws/services/acm_mocks.go @@ -0,0 +1,67 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services (interfaces: ACM) + +// Package services is a generated GoMock package. +package services + +import ( + context "context" + reflect "reflect" + + acm "github.com/aws/aws-sdk-go-v2/service/acm" + types "github.com/aws/aws-sdk-go-v2/service/acm/types" + gomock "github.com/golang/mock/gomock" +) + +// MockACM is a mock of ACM interface. +type MockACM struct { + ctrl *gomock.Controller + recorder *MockACMMockRecorder +} + +// MockACMMockRecorder is the mock recorder for MockACM. +type MockACMMockRecorder struct { + mock *MockACM +} + +// NewMockACM creates a new mock instance. +func NewMockACM(ctrl *gomock.Controller) *MockACM { + mock := &MockACM{ctrl: ctrl} + mock.recorder = &MockACMMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockACM) EXPECT() *MockACMMockRecorder { + return m.recorder +} + +// DescribeCertificateWithContext mocks base method. +func (m *MockACM) DescribeCertificateWithContext(arg0 context.Context, arg1 *acm.DescribeCertificateInput) (*acm.DescribeCertificateOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeCertificateWithContext", arg0, arg1) + ret0, _ := ret[0].(*acm.DescribeCertificateOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeCertificateWithContext indicates an expected call of DescribeCertificateWithContext. +func (mr *MockACMMockRecorder) DescribeCertificateWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificateWithContext", reflect.TypeOf((*MockACM)(nil).DescribeCertificateWithContext), arg0, arg1) +} + +// ListCertificatesAsList mocks base method. +func (m *MockACM) ListCertificatesAsList(arg0 context.Context, arg1 *acm.ListCertificatesInput) ([]types.CertificateSummary, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListCertificatesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.CertificateSummary) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListCertificatesAsList indicates an expected call of ListCertificatesAsList. +func (mr *MockACMMockRecorder) ListCertificatesAsList(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesAsList", reflect.TypeOf((*MockACM)(nil).ListCertificatesAsList), arg0, arg1) +} diff --git a/pkg/aws/services/ec2.go b/pkg/aws/services/ec2.go index 80230f96f3..7728063818 100644 --- a/pkg/aws/services/ec2.go +++ b/pkg/aws/services/ec2.go @@ -2,95 +2,149 @@ package services import ( "context" - - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/ec2" - "github.com/aws/aws-sdk-go/service/ec2/ec2iface" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/ec2" + "github.com/aws/aws-sdk-go-v2/service/ec2/types" ) type EC2 interface { - ec2iface.EC2API // DescribeInstancesAsList wraps the DescribeInstancesPagesWithContext API, which aggregates paged results into list. - DescribeInstancesAsList(ctx context.Context, input *ec2.DescribeInstancesInput) ([]*ec2.Instance, error) + DescribeInstancesAsList(ctx context.Context, input *ec2.DescribeInstancesInput) ([]types.Instance, error) // DescribeNetworkInterfacesAsList wraps the DescribeNetworkInterfacesPagesWithContext API, which aggregates paged results into list. - DescribeNetworkInterfacesAsList(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]*ec2.NetworkInterface, error) + DescribeNetworkInterfacesAsList(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]types.NetworkInterface, error) // DescribeSecurityGroupsAsList wraps the DescribeSecurityGroupsPagesWithContext API, which aggregates paged results into list. - DescribeSecurityGroupsAsList(ctx context.Context, input *ec2.DescribeSecurityGroupsInput) ([]*ec2.SecurityGroup, error) + DescribeSecurityGroupsAsList(ctx context.Context, input *ec2.DescribeSecurityGroupsInput) ([]types.SecurityGroup, error) // DescribeSubnetsAsList wraps the DescribeSubnetsPagesWithContext API, which aggregates paged results into list. - DescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error) + DescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]types.Subnet, error) // DescribeVPCsAsList wraps the DescribeVpcsPagesWithContext API, which aggregates paged results into list. - DescribeVPCsAsList(ctx context.Context, input *ec2.DescribeVpcsInput) ([]*ec2.Vpc, error) + DescribeVPCsAsList(ctx context.Context, input *ec2.DescribeVpcsInput) ([]types.Vpc, error) + + CreateTagsWithContext(ctx context.Context, input *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) + DeleteTagsWithContext(ctx context.Context, input *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) + CreateSecurityGroupWithContext(ctx context.Context, input *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) + DeleteSecurityGroupWithContext(ctx context.Context, input *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) + AuthorizeSecurityGroupIngressWithContext(ctx context.Context, input *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) + RevokeSecurityGroupIngressWithContext(ctx context.Context, input *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) + DescribeAvailabilityZonesWithContext(ctx context.Context, input *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) + DescribeVpcsWithContext(ctx context.Context, input *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) + DescribeInstancesWithContext(ctx context.Context, input *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) } // NewEC2 constructs new EC2 implementation. -func NewEC2(session *session.Session) EC2 { - return &defaultEC2{ - EC2API: ec2.New(session), +func NewEC2(cfg aws.Config) EC2 { + return &ec2Client{ + ec2Client: ec2.NewFromConfig(cfg), } } -type defaultEC2 struct { - ec2iface.EC2API +type ec2Client struct { + ec2Client *ec2.Client +} + +func (c *ec2Client) DescribeInstancesWithContext(ctx context.Context, input *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { + return c.ec2Client.DescribeInstances(ctx, input) } -func (c *defaultEC2) DescribeInstancesAsList(ctx context.Context, input *ec2.DescribeInstancesInput) ([]*ec2.Instance, error) { - var result []*ec2.Instance - if err := c.DescribeInstancesPagesWithContext(ctx, input, func(output *ec2.DescribeInstancesOutput, _ bool) bool { +func (c *ec2Client) DescribeInstancesAsList(ctx context.Context, input *ec2.DescribeInstancesInput) ([]types.Instance, error) { + var result []types.Instance + paginator := ec2.NewDescribeInstancesPaginator(c.ec2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } for _, reservation := range output.Reservations { result = append(result, reservation.Instances...) } - return true - }); err != nil { - return nil, err } return result, nil } -func (c *defaultEC2) DescribeNetworkInterfacesAsList(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]*ec2.NetworkInterface, error) { - var result []*ec2.NetworkInterface - if err := c.DescribeNetworkInterfacesPagesWithContext(ctx, input, func(output *ec2.DescribeNetworkInterfacesOutput, _ bool) bool { +func (c *ec2Client) DescribeNetworkInterfacesAsList(ctx context.Context, input *ec2.DescribeNetworkInterfacesInput) ([]types.NetworkInterface, error) { + var result []types.NetworkInterface + paginator := ec2.NewDescribeNetworkInterfacesPaginator(c.ec2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } result = append(result, output.NetworkInterfaces...) - return true - }); err != nil { - return nil, err } return result, nil } -func (c *defaultEC2) DescribeSecurityGroupsAsList(ctx context.Context, input *ec2.DescribeSecurityGroupsInput) ([]*ec2.SecurityGroup, error) { - var result []*ec2.SecurityGroup - if err := c.DescribeSecurityGroupsPagesWithContext(ctx, input, func(output *ec2.DescribeSecurityGroupsOutput, _ bool) bool { +func (c *ec2Client) DescribeSecurityGroupsAsList(ctx context.Context, input *ec2.DescribeSecurityGroupsInput) ([]types.SecurityGroup, error) { + var result []types.SecurityGroup + paginator := ec2.NewDescribeSecurityGroupsPaginator(c.ec2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } result = append(result, output.SecurityGroups...) - return true - }); err != nil { - return nil, err } return result, nil } -func (c *defaultEC2) DescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error) { - var result []*ec2.Subnet - if err := c.DescribeSubnetsPagesWithContext(ctx, input, func(output *ec2.DescribeSubnetsOutput, _ bool) bool { +func (c *ec2Client) DescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]types.Subnet, error) { + var result []types.Subnet + paginator := ec2.NewDescribeSubnetsPaginator(c.ec2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } result = append(result, output.Subnets...) - return true - }); err != nil { - return nil, err } return result, nil } -func (c *defaultEC2) DescribeVPCsAsList(ctx context.Context, input *ec2.DescribeVpcsInput) ([]*ec2.Vpc, error) { - var result []*ec2.Vpc - if err := c.DescribeVpcsPagesWithContext(ctx, input, func(output *ec2.DescribeVpcsOutput, _ bool) bool { +func (c *ec2Client) DescribeVPCsAsList(ctx context.Context, input *ec2.DescribeVpcsInput) ([]types.Vpc, error) { + var result []types.Vpc + paginator := ec2.NewDescribeVpcsPaginator(c.ec2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } result = append(result, output.Vpcs...) - return true - }); err != nil { - return nil, err } return result, nil } + +func (c *ec2Client) CreateTagsWithContext(ctx context.Context, input *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { + return c.ec2Client.CreateTags(ctx, input) +} + +func (c *ec2Client) DeleteTagsWithContext(ctx context.Context, input *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) { + return c.ec2Client.DeleteTags(ctx, input) +} + +func (c *ec2Client) CreateSecurityGroupWithContext(ctx context.Context, input *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) { + return c.ec2Client.CreateSecurityGroup(ctx, input) +} + +func (c *ec2Client) DeleteSecurityGroupWithContext(ctx context.Context, input *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) { + return c.ec2Client.DeleteSecurityGroup(ctx, input) +} + +func (c *ec2Client) AuthorizeSecurityGroupIngressWithContext(ctx context.Context, input *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { + return c.ec2Client.AuthorizeSecurityGroupIngress(ctx, input) +} + +func (c *ec2Client) RevokeSecurityGroupIngressWithContext(ctx context.Context, input *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) { + return c.ec2Client.RevokeSecurityGroupIngress(ctx, input) +} + +func (c *ec2Client) DescribeAvailabilityZonesWithContext(ctx context.Context, input *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) { + return c.ec2Client.DescribeAvailabilityZones(ctx, input) +} + +func (c *ec2Client) DescribeVpcsWithContext(ctx context.Context, input *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) { + return c.ec2Client.DescribeVpcs(ctx, input) +} diff --git a/pkg/aws/services/ec2_metadata.go b/pkg/aws/services/ec2_metadata.go index 879a6d5001..f17ae6abcb 100644 --- a/pkg/aws/services/ec2_metadata.go +++ b/pkg/aws/services/ec2_metadata.go @@ -1,9 +1,11 @@ package services import ( + "context" "fmt" - "github.com/aws/aws-sdk-go/aws/ec2metadata" - "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/feature/ec2/imds" + "io" ) type EC2Metadata interface { @@ -12,24 +14,44 @@ type EC2Metadata interface { } // NewEC2Metadata constructs new EC2Metadata implementation. -func NewEC2Metadata(session *session.Session) EC2Metadata { - return &defaultEC2Metadata{ - EC2Metadata: ec2metadata.New(session), +func NewEC2Metadata(cfg aws.Config) EC2Metadata { + return &ec2metadataClient{ + ec2metadataClient: imds.NewFromConfig(cfg), } } -type defaultEC2Metadata struct { - *ec2metadata.EC2Metadata +type ec2metadataClient struct { + ec2metadataClient *imds.Client } -func (c *defaultEC2Metadata) VpcID() (string, error) { - mac, err := c.GetMetadata("mac") +func (c *ec2metadataClient) Region() (string, error) { + output, err := c.ec2metadataClient.GetRegion(context.TODO(), &imds.GetRegionInput{}) if err != nil { return "", err } - vpcID, err := c.GetMetadata(fmt.Sprintf("network/interfaces/macs/%s/vpc-id", mac)) + return output.Region, nil +} + +func (c *ec2metadataClient) VpcID() (string, error) { + mac, err := c.getMetadata("mac") if err != nil { - return "", err + return "", fmt.Errorf("error in fetching vpc id through ec2 metadata: %w", err) + } + vpcId, err := c.getMetadata(fmt.Sprintf("network/interfaces/macs/%s/vpc-id", mac)) + if err != nil { + return "", fmt.Errorf("error in fetching vpc id through ec2 metadata: %w", err) + } + return vpcId, nil +} + +func (c *ec2metadataClient) getMetadata(path string) (string, error) { + data, err := c.ec2metadataClient.GetMetadata(context.TODO(), &imds.GetMetadataInput{Path: path}) + if err != nil { + return "", fmt.Errorf("get %s metadata: %w", path, err) + } + out, err := io.ReadAll(data.Content) + if err != nil { + return "", fmt.Errorf("read %s metadata: %w", path, err) } - return vpcID, nil + return string(out), nil } diff --git a/pkg/aws/services/ec2_metadata_mocks.go b/pkg/aws/services/ec2_metadata_mocks.go new file mode 100644 index 0000000000..2c0d938261 --- /dev/null +++ b/pkg/aws/services/ec2_metadata_mocks.go @@ -0,0 +1,64 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services (interfaces: EC2Metadata) + +// Package services is a generated GoMock package. +package services + +import ( + reflect "reflect" + + gomock "github.com/golang/mock/gomock" +) + +// MockEC2Metadata is a mock of EC2Metadata interface. +type MockEC2Metadata struct { + ctrl *gomock.Controller + recorder *MockEC2MetadataMockRecorder +} + +// MockEC2MetadataMockRecorder is the mock recorder for MockEC2Metadata. +type MockEC2MetadataMockRecorder struct { + mock *MockEC2Metadata +} + +// NewMockEC2Metadata creates a new mock instance. +func NewMockEC2Metadata(ctrl *gomock.Controller) *MockEC2Metadata { + mock := &MockEC2Metadata{ctrl: ctrl} + mock.recorder = &MockEC2MetadataMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockEC2Metadata) EXPECT() *MockEC2MetadataMockRecorder { + return m.recorder +} + +// Region mocks base method. +func (m *MockEC2Metadata) Region() (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Region") + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Region indicates an expected call of Region. +func (mr *MockEC2MetadataMockRecorder) Region() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Region", reflect.TypeOf((*MockEC2Metadata)(nil).Region)) +} + +// VpcID mocks base method. +func (m *MockEC2Metadata) VpcID() (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VpcID") + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VpcID indicates an expected call of VpcID. +func (mr *MockEC2MetadataMockRecorder) VpcID() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VpcID", reflect.TypeOf((*MockEC2Metadata)(nil).VpcID)) +} diff --git a/pkg/aws/services/ec2_mocks.go b/pkg/aws/services/ec2_mocks.go index e3ffd34e3d..00a6dc886d 100644 --- a/pkg/aws/services/ec2_mocks.go +++ b/pkg/aws/services/ec2_mocks.go @@ -8,8 +8,8 @@ import ( context "context" reflect "reflect" - request "github.com/aws/aws-sdk-go/aws/request" - ec2 "github.com/aws/aws-sdk-go/service/ec2" + ec2 "github.com/aws/aws-sdk-go-v2/service/ec2" + types "github.com/aws/aws-sdk-go-v2/service/ec2/types" gomock "github.com/golang/mock/gomock" ) @@ -36,36602 +36,212 @@ func (m *MockEC2) EXPECT() *MockEC2MockRecorder { return m.recorder } -// AcceptAddressTransfer mocks base method. -func (m *MockEC2) AcceptAddressTransfer(arg0 *ec2.AcceptAddressTransferInput) (*ec2.AcceptAddressTransferOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptAddressTransfer", arg0) - ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptAddressTransfer indicates an expected call of AcceptAddressTransfer. -func (mr *MockEC2MockRecorder) AcceptAddressTransfer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransfer", reflect.TypeOf((*MockEC2)(nil).AcceptAddressTransfer), arg0) -} - -// AcceptAddressTransferRequest mocks base method. -func (m *MockEC2) AcceptAddressTransferRequest(arg0 *ec2.AcceptAddressTransferInput) (*request.Request, *ec2.AcceptAddressTransferOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptAddressTransferRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptAddressTransferOutput) - return ret0, ret1 -} - -// AcceptAddressTransferRequest indicates an expected call of AcceptAddressTransferRequest. -func (mr *MockEC2MockRecorder) AcceptAddressTransferRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptAddressTransferRequest", reflect.TypeOf((*MockEC2)(nil).AcceptAddressTransferRequest), arg0) -} - -// AcceptAddressTransferWithContext mocks base method. -func (m *MockEC2) AcceptAddressTransferWithContext(arg0 context.Context, arg1 *ec2.AcceptAddressTransferInput, arg2 ...request.Option) (*ec2.AcceptAddressTransferOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptAddressTransferWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptAddressTransferWithContext indicates an expected call of AcceptAddressTransferWithContext. -func (mr *MockEC2MockRecorder) AcceptAddressTransferWithContext(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, "AcceptAddressTransferWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptAddressTransferWithContext), varargs...) -} - -// AcceptReservedInstancesExchangeQuote mocks base method. -func (m *MockEC2) AcceptReservedInstancesExchangeQuote(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuote", arg0) - ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptReservedInstancesExchangeQuote indicates an expected call of AcceptReservedInstancesExchangeQuote. -func (mr *MockEC2MockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2)(nil).AcceptReservedInstancesExchangeQuote), arg0) -} - -// AcceptReservedInstancesExchangeQuoteRequest mocks base method. -func (m *MockEC2) AcceptReservedInstancesExchangeQuoteRequest(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) - return ret0, ret1 -} - -// AcceptReservedInstancesExchangeQuoteRequest indicates an expected call of AcceptReservedInstancesExchangeQuoteRequest. -func (mr *MockEC2MockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0) -} - -// AcceptReservedInstancesExchangeQuoteWithContext mocks base method. -func (m *MockEC2) AcceptReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.AcceptReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptReservedInstancesExchangeQuoteWithContext indicates an expected call of AcceptReservedInstancesExchangeQuoteWithContext. -func (mr *MockEC2MockRecorder) AcceptReservedInstancesExchangeQuoteWithContext(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, "AcceptReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...) -} - -// AcceptTransitGatewayMulticastDomainAssociations mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AcceptTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayMulticastDomainAssociations), arg0) -} - -// AcceptTransitGatewayMulticastDomainAssociationsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AcceptTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayMulticastDomainAssociationsRequest), arg0) -} - -// AcceptTransitGatewayMulticastDomainAssociationsWithContext mocks base method. -func (m *MockEC2) AcceptTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).AcceptTransitGatewayMulticastDomainAssociationsWithContext), varargs...) -} - -// AcceptTransitGatewayPeeringAttachment mocks base method. -func (m *MockEC2) AcceptTransitGatewayPeeringAttachment(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachment", arg0) - ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptTransitGatewayPeeringAttachment indicates an expected call of AcceptTransitGatewayPeeringAttachment. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayPeeringAttachment), arg0) -} - -// AcceptTransitGatewayPeeringAttachmentRequest mocks base method. -func (m *MockEC2) AcceptTransitGatewayPeeringAttachmentRequest(arg0 *ec2.AcceptTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayPeeringAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) - return ret0, ret1 -} - -// AcceptTransitGatewayPeeringAttachmentRequest indicates an expected call of AcceptTransitGatewayPeeringAttachmentRequest. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayPeeringAttachmentRequest), arg0) -} - -// AcceptTransitGatewayPeeringAttachmentWithContext mocks base method. -func (m *MockEC2) AcceptTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptTransitGatewayPeeringAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptTransitGatewayPeeringAttachmentWithContext indicates an expected call of AcceptTransitGatewayPeeringAttachmentWithContext. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayPeeringAttachmentWithContext(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, "AcceptTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayPeeringAttachmentWithContext), varargs...) -} - -// AcceptTransitGatewayVpcAttachment mocks base method. -func (m *MockEC2) AcceptTransitGatewayVpcAttachment(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachment", arg0) - ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptTransitGatewayVpcAttachment indicates an expected call of AcceptTransitGatewayVpcAttachment. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayVpcAttachment), arg0) -} - -// AcceptTransitGatewayVpcAttachmentRequest mocks base method. -func (m *MockEC2) AcceptTransitGatewayVpcAttachmentRequest(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) - return ret0, ret1 -} - -// AcceptTransitGatewayVpcAttachmentRequest indicates an expected call of AcceptTransitGatewayVpcAttachmentRequest. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0) -} - -// AcceptTransitGatewayVpcAttachmentWithContext mocks base method. -func (m *MockEC2) AcceptTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.AcceptTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptTransitGatewayVpcAttachmentWithContext indicates an expected call of AcceptTransitGatewayVpcAttachmentWithContext. -func (mr *MockEC2MockRecorder) AcceptTransitGatewayVpcAttachmentWithContext(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, "AcceptTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptTransitGatewayVpcAttachmentWithContext), varargs...) -} - -// AcceptVpcEndpointConnections mocks base method. -func (m *MockEC2) AcceptVpcEndpointConnections(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptVpcEndpointConnections", arg0) - ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptVpcEndpointConnections indicates an expected call of AcceptVpcEndpointConnections. -func (mr *MockEC2MockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2)(nil).AcceptVpcEndpointConnections), arg0) -} - -// AcceptVpcEndpointConnectionsRequest mocks base method. -func (m *MockEC2) AcceptVpcEndpointConnectionsRequest(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptVpcEndpointConnectionsOutput) - return ret0, ret1 -} - -// AcceptVpcEndpointConnectionsRequest indicates an expected call of AcceptVpcEndpointConnectionsRequest. -func (mr *MockEC2MockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).AcceptVpcEndpointConnectionsRequest), arg0) -} - -// AcceptVpcEndpointConnectionsWithContext mocks base method. -func (m *MockEC2) AcceptVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptVpcEndpointConnectionsWithContext indicates an expected call of AcceptVpcEndpointConnectionsWithContext. -func (mr *MockEC2MockRecorder) AcceptVpcEndpointConnectionsWithContext(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, "AcceptVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptVpcEndpointConnectionsWithContext), varargs...) -} - -// AcceptVpcPeeringConnection mocks base method. -func (m *MockEC2) AcceptVpcPeeringConnection(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptVpcPeeringConnection", arg0) - ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AcceptVpcPeeringConnection indicates an expected call of AcceptVpcPeeringConnection. -func (mr *MockEC2MockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2)(nil).AcceptVpcPeeringConnection), arg0) -} - -// AcceptVpcPeeringConnectionRequest mocks base method. -func (m *MockEC2) AcceptVpcPeeringConnectionRequest(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AcceptVpcPeeringConnectionOutput) - return ret0, ret1 -} - -// AcceptVpcPeeringConnectionRequest indicates an expected call of AcceptVpcPeeringConnectionRequest. -func (mr *MockEC2MockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2)(nil).AcceptVpcPeeringConnectionRequest), arg0) -} - -// AcceptVpcPeeringConnectionWithContext mocks base method. -func (m *MockEC2) AcceptVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, error) { +// AuthorizeSecurityGroupIngressWithContext mocks base method. +func (m *MockEC2) AuthorizeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) + ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AcceptVpcPeeringConnectionWithContext indicates an expected call of AcceptVpcPeeringConnectionWithContext. -func (mr *MockEC2MockRecorder) AcceptVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// AuthorizeSecurityGroupIngressWithContext indicates an expected call of AuthorizeSecurityGroupIngressWithContext. +func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupIngressWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).AcceptVpcPeeringConnectionWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupIngressWithContext), arg0, arg1) } -// AdvertiseByoipCidr mocks base method. -func (m *MockEC2) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) { +// CreateSecurityGroupWithContext mocks base method. +func (m *MockEC2) CreateSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0) - ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) + ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr. -func (mr *MockEC2MockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2)(nil).AdvertiseByoipCidr), arg0) -} - -// AdvertiseByoipCidrRequest mocks base method. -func (m *MockEC2) AdvertiseByoipCidrRequest(arg0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AdvertiseByoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AdvertiseByoipCidrOutput) - return ret0, ret1 -} - -// AdvertiseByoipCidrRequest indicates an expected call of AdvertiseByoipCidrRequest. -func (mr *MockEC2MockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call { +// CreateSecurityGroupWithContext indicates an expected call of CreateSecurityGroupWithContext. +func (mr *MockEC2MockRecorder) CreateSecurityGroupWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).AdvertiseByoipCidrRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSecurityGroupWithContext), arg0, arg1) } -// AdvertiseByoipCidrWithContext mocks base method. -func (m *MockEC2) AdvertiseByoipCidrWithContext(arg0 context.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, error) { +// CreateTagsWithContext mocks base method. +func (m *MockEC2) CreateTagsWithContext(arg0 context.Context, arg1 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AdvertiseByoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) + ret := m.ctrl.Call(m, "CreateTagsWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.CreateTagsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AdvertiseByoipCidrWithContext indicates an expected call of AdvertiseByoipCidrWithContext. -func (mr *MockEC2MockRecorder) AdvertiseByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// CreateTagsWithContext indicates an expected call of CreateTagsWithContext. +func (mr *MockEC2MockRecorder) CreateTagsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).AdvertiseByoipCidrWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTagsWithContext), arg0, arg1) } -// AllocateAddress mocks base method. -func (m *MockEC2) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) { +// DeleteSecurityGroupWithContext mocks base method. +func (m *MockEC2) DeleteSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateAddress", arg0) - ret0, _ := ret[0].(*ec2.AllocateAddressOutput) + ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateAddress indicates an expected call of AllocateAddress. -func (mr *MockEC2MockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2)(nil).AllocateAddress), arg0) -} - -// AllocateAddressRequest mocks base method. -func (m *MockEC2) AllocateAddressRequest(arg0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateAddressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AllocateAddressOutput) - return ret0, ret1 -} - -// AllocateAddressRequest indicates an expected call of AllocateAddressRequest. -func (mr *MockEC2MockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call { +// DeleteSecurityGroupWithContext indicates an expected call of DeleteSecurityGroupWithContext. +func (mr *MockEC2MockRecorder) DeleteSecurityGroupWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2)(nil).AllocateAddressRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSecurityGroupWithContext), arg0, arg1) } -// AllocateAddressWithContext mocks base method. -func (m *MockEC2) AllocateAddressWithContext(arg0 context.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, error) { +// DeleteTagsWithContext mocks base method. +func (m *MockEC2) DeleteTagsWithContext(arg0 context.Context, arg1 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AllocateAddressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AllocateAddressOutput) + ret := m.ctrl.Call(m, "DeleteTagsWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.DeleteTagsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateAddressWithContext indicates an expected call of AllocateAddressWithContext. -func (mr *MockEC2MockRecorder) AllocateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext. +func (mr *MockEC2MockRecorder) DeleteTagsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressWithContext", reflect.TypeOf((*MockEC2)(nil).AllocateAddressWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTagsWithContext), arg0, arg1) } -// AllocateHosts mocks base method. -func (m *MockEC2) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) { +// DescribeAvailabilityZonesWithContext mocks base method. +func (m *MockEC2) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateHosts", arg0) - ret0, _ := ret[0].(*ec2.AllocateHostsOutput) + ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateHosts indicates an expected call of AllocateHosts. -func (mr *MockEC2MockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2)(nil).AllocateHosts), arg0) -} - -// AllocateHostsRequest mocks base method. -func (m *MockEC2) AllocateHostsRequest(arg0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateHostsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AllocateHostsOutput) - return ret0, ret1 -} - -// AllocateHostsRequest indicates an expected call of AllocateHostsRequest. -func (mr *MockEC2MockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call { +// DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext. +func (mr *MockEC2MockRecorder) DescribeAvailabilityZonesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2)(nil).AllocateHostsRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAvailabilityZonesWithContext), arg0, arg1) } -// AllocateHostsWithContext mocks base method. -func (m *MockEC2) AllocateHostsWithContext(arg0 context.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, error) { +// DescribeInstancesAsList mocks base method. +func (m *MockEC2) DescribeInstancesAsList(arg0 context.Context, arg1 *ec2.DescribeInstancesInput) ([]types.Instance, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AllocateHostsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AllocateHostsOutput) + ret := m.ctrl.Call(m, "DescribeInstancesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Instance) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateHostsWithContext indicates an expected call of AllocateHostsWithContext. -func (mr *MockEC2MockRecorder) AllocateHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeInstancesAsList indicates an expected call of DescribeInstancesAsList. +func (mr *MockEC2MockRecorder) DescribeInstancesAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsWithContext", reflect.TypeOf((*MockEC2)(nil).AllocateHostsWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesAsList", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesAsList), arg0, arg1) } -// AllocateIpamPoolCidr mocks base method. -func (m *MockEC2) AllocateIpamPoolCidr(arg0 *ec2.AllocateIpamPoolCidrInput) (*ec2.AllocateIpamPoolCidrOutput, error) { +// DescribeInstancesWithContext mocks base method. +func (m *MockEC2) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateIpamPoolCidr", arg0) - ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput) + ret := m.ctrl.Call(m, "DescribeInstancesWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateIpamPoolCidr indicates an expected call of AllocateIpamPoolCidr. -func (mr *MockEC2MockRecorder) AllocateIpamPoolCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidr", reflect.TypeOf((*MockEC2)(nil).AllocateIpamPoolCidr), arg0) -} - -// AllocateIpamPoolCidrRequest mocks base method. -func (m *MockEC2) AllocateIpamPoolCidrRequest(arg0 *ec2.AllocateIpamPoolCidrInput) (*request.Request, *ec2.AllocateIpamPoolCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AllocateIpamPoolCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AllocateIpamPoolCidrOutput) - return ret0, ret1 -} - -// AllocateIpamPoolCidrRequest indicates an expected call of AllocateIpamPoolCidrRequest. -func (mr *MockEC2MockRecorder) AllocateIpamPoolCidrRequest(arg0 interface{}) *gomock.Call { +// DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext. +func (mr *MockEC2MockRecorder) DescribeInstancesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidrRequest", reflect.TypeOf((*MockEC2)(nil).AllocateIpamPoolCidrRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesWithContext), arg0, arg1) } -// AllocateIpamPoolCidrWithContext mocks base method. -func (m *MockEC2) AllocateIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.AllocateIpamPoolCidrInput, arg2 ...request.Option) (*ec2.AllocateIpamPoolCidrOutput, error) { +// DescribeNetworkInterfacesAsList mocks base method. +func (m *MockEC2) DescribeNetworkInterfacesAsList(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput) ([]types.NetworkInterface, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AllocateIpamPoolCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AllocateIpamPoolCidrOutput) + ret := m.ctrl.Call(m, "DescribeNetworkInterfacesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.NetworkInterface) ret1, _ := ret[1].(error) return ret0, ret1 } -// AllocateIpamPoolCidrWithContext indicates an expected call of AllocateIpamPoolCidrWithContext. -func (mr *MockEC2MockRecorder) AllocateIpamPoolCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeNetworkInterfacesAsList indicates an expected call of DescribeNetworkInterfacesAsList. +func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2)(nil).AllocateIpamPoolCidrWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesAsList", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesAsList), arg0, arg1) } -// ApplySecurityGroupsToClientVpnTargetNetwork mocks base method. -func (m *MockEC2) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { +// DescribeSecurityGroupsAsList mocks base method. +func (m *MockEC2) DescribeSecurityGroupsAsList(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput) ([]types.SecurityGroup, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0) - ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) + ret := m.ctrl.Call(m, "DescribeSecurityGroupsAsList", arg0, arg1) + ret0, _ := ret[0].([]types.SecurityGroup) ret1, _ := ret[1].(error) return ret0, ret1 } -// ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork. -func (mr *MockEC2MockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0) -} - -// ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method. -func (m *MockEC2) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) - return ret0, ret1 -} - -// ApplySecurityGroupsToClientVpnTargetNetworkRequest indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkRequest. -func (mr *MockEC2MockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { +// DescribeSecurityGroupsAsList indicates an expected call of DescribeSecurityGroupsAsList. +func (mr *MockEC2MockRecorder) DescribeSecurityGroupsAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsAsList), arg0, arg1) } -// ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method. -func (m *MockEC2) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { +// DescribeSubnetsAsList mocks base method. +func (m *MockEC2) DescribeSubnetsAsList(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput) ([]types.Subnet, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) + ret := m.ctrl.Call(m, "DescribeSubnetsAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Subnet) ret1, _ := ret[1].(error) return ret0, ret1 } -// ApplySecurityGroupsToClientVpnTargetNetworkWithContext indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkWithContext. -func (mr *MockEC2MockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeSubnetsAsList indicates an expected call of DescribeSubnetsAsList. +func (mr *MockEC2MockRecorder) DescribeSubnetsAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2)(nil).ApplySecurityGroupsToClientVpnTargetNetworkWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeSubnetsAsList), arg0, arg1) } -// AssignIpv6Addresses mocks base method. -func (m *MockEC2) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) { +// DescribeVPCsAsList mocks base method. +func (m *MockEC2) DescribeVPCsAsList(arg0 context.Context, arg1 *ec2.DescribeVpcsInput) ([]types.Vpc, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0) - ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) + ret := m.ctrl.Call(m, "DescribeVPCsAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Vpc) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses. -func (mr *MockEC2MockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2)(nil).AssignIpv6Addresses), arg0) -} - -// AssignIpv6AddressesRequest mocks base method. -func (m *MockEC2) AssignIpv6AddressesRequest(arg0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssignIpv6AddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssignIpv6AddressesOutput) - return ret0, ret1 -} - -// AssignIpv6AddressesRequest indicates an expected call of AssignIpv6AddressesRequest. -func (mr *MockEC2MockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { +// DescribeVPCsAsList indicates an expected call of DescribeVPCsAsList. +func (mr *MockEC2MockRecorder) DescribeVPCsAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2)(nil).AssignIpv6AddressesRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVPCsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeVPCsAsList), arg0, arg1) } -// AssignIpv6AddressesWithContext mocks base method. -func (m *MockEC2) AssignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, error) { +// DescribeVpcsWithContext mocks base method. +func (m *MockEC2) DescribeVpcsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssignIpv6AddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) + ret := m.ctrl.Call(m, "DescribeVpcsWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssignIpv6AddressesWithContext indicates an expected call of AssignIpv6AddressesWithContext. -func (mr *MockEC2MockRecorder) AssignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeVpcsWithContext indicates an expected call of DescribeVpcsWithContext. +func (mr *MockEC2MockRecorder) DescribeVpcsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2)(nil).AssignIpv6AddressesWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcsWithContext), arg0, arg1) } -// AssignPrivateIpAddresses mocks base method. -func (m *MockEC2) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { +// RevokeSecurityGroupIngressWithContext mocks base method. +func (m *MockEC2) RevokeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0) - ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) + ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", arg0, arg1) + ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses. -func (mr *MockEC2MockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2)(nil).AssignPrivateIpAddresses), arg0) -} - -// AssignPrivateIpAddressesRequest mocks base method. -func (m *MockEC2) AssignPrivateIpAddressesRequest(arg0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssignPrivateIpAddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssignPrivateIpAddressesOutput) - return ret0, ret1 -} - -// AssignPrivateIpAddressesRequest indicates an expected call of AssignPrivateIpAddressesRequest. -func (mr *MockEC2MockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2)(nil).AssignPrivateIpAddressesRequest), arg0) -} - -// AssignPrivateIpAddressesWithContext mocks base method. -func (m *MockEC2) AssignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.AssignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssignPrivateIpAddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssignPrivateIpAddressesWithContext indicates an expected call of AssignPrivateIpAddressesWithContext. -func (mr *MockEC2MockRecorder) AssignPrivateIpAddressesWithContext(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, "AssignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2)(nil).AssignPrivateIpAddressesWithContext), varargs...) -} - -// AssignPrivateNatGatewayAddress mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2)(nil).AssignPrivateNatGatewayAddress), arg0) -} - -// AssignPrivateNatGatewayAddressRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2)(nil).AssignPrivateNatGatewayAddressRequest), arg0) -} - -// AssignPrivateNatGatewayAddressWithContext mocks base method. -func (m *MockEC2) AssignPrivateNatGatewayAddressWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).AssignPrivateNatGatewayAddressWithContext), varargs...) -} - -// AssociateAddress mocks base method. -func (m *MockEC2) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateAddress", arg0) - ret0, _ := ret[0].(*ec2.AssociateAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateAddress indicates an expected call of AssociateAddress. -func (mr *MockEC2MockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2)(nil).AssociateAddress), arg0) -} - -// AssociateAddressRequest mocks base method. -func (m *MockEC2) AssociateAddressRequest(arg0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateAddressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateAddressOutput) - return ret0, ret1 -} - -// AssociateAddressRequest indicates an expected call of AssociateAddressRequest. -func (mr *MockEC2MockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2)(nil).AssociateAddressRequest), arg0) -} - -// AssociateAddressWithContext mocks base method. -func (m *MockEC2) AssociateAddressWithContext(arg0 context.Context, arg1 *ec2.AssociateAddressInput, arg2 ...request.Option) (*ec2.AssociateAddressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateAddressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateAddressWithContext indicates an expected call of AssociateAddressWithContext. -func (mr *MockEC2MockRecorder) AssociateAddressWithContext(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, "AssociateAddressWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateAddressWithContext), varargs...) -} - -// AssociateClientVpnTargetNetwork mocks base method. -func (m *MockEC2) AssociateClientVpnTargetNetwork(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetwork", arg0) - ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateClientVpnTargetNetwork indicates an expected call of AssociateClientVpnTargetNetwork. -func (mr *MockEC2MockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2)(nil).AssociateClientVpnTargetNetwork), arg0) -} - -// AssociateClientVpnTargetNetworkRequest mocks base method. -func (m *MockEC2) AssociateClientVpnTargetNetworkRequest(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateClientVpnTargetNetworkOutput) - return ret0, ret1 -} - -// AssociateClientVpnTargetNetworkRequest indicates an expected call of AssociateClientVpnTargetNetworkRequest. -func (mr *MockEC2MockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2)(nil).AssociateClientVpnTargetNetworkRequest), arg0) -} - -// AssociateClientVpnTargetNetworkWithContext mocks base method. -func (m *MockEC2) AssociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.AssociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateClientVpnTargetNetworkWithContext indicates an expected call of AssociateClientVpnTargetNetworkWithContext. -func (mr *MockEC2MockRecorder) AssociateClientVpnTargetNetworkWithContext(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, "AssociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateClientVpnTargetNetworkWithContext), varargs...) -} - -// AssociateDhcpOptions mocks base method. -func (m *MockEC2) AssociateDhcpOptions(arg0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDhcpOptions", arg0) - ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDhcpOptions indicates an expected call of AssociateDhcpOptions. -func (mr *MockEC2MockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2)(nil).AssociateDhcpOptions), arg0) -} - -// AssociateDhcpOptionsRequest mocks base method. -func (m *MockEC2) AssociateDhcpOptionsRequest(arg0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDhcpOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateDhcpOptionsOutput) - return ret0, ret1 -} - -// AssociateDhcpOptionsRequest indicates an expected call of AssociateDhcpOptionsRequest. -func (mr *MockEC2MockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2)(nil).AssociateDhcpOptionsRequest), arg0) -} - -// AssociateDhcpOptionsWithContext mocks base method. -func (m *MockEC2) AssociateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.AssociateDhcpOptionsInput, arg2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateDhcpOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDhcpOptionsWithContext indicates an expected call of AssociateDhcpOptionsWithContext. -func (mr *MockEC2MockRecorder) AssociateDhcpOptionsWithContext(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, "AssociateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateDhcpOptionsWithContext), varargs...) -} - -// AssociateEnclaveCertificateIamRole mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2)(nil).AssociateEnclaveCertificateIamRole), arg0) -} - -// AssociateEnclaveCertificateIamRoleRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2)(nil).AssociateEnclaveCertificateIamRoleRequest), arg0) -} - -// AssociateEnclaveCertificateIamRoleWithContext mocks base method. -func (m *MockEC2) AssociateEnclaveCertificateIamRoleWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).AssociateEnclaveCertificateIamRoleWithContext), varargs...) -} - -// AssociateIamInstanceProfile mocks base method. -func (m *MockEC2) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIamInstanceProfile", arg0) - ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIamInstanceProfile indicates an expected call of AssociateIamInstanceProfile. -func (mr *MockEC2MockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2)(nil).AssociateIamInstanceProfile), arg0) -} - -// AssociateIamInstanceProfileRequest mocks base method. -func (m *MockEC2) AssociateIamInstanceProfileRequest(arg0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIamInstanceProfileRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateIamInstanceProfileOutput) - return ret0, ret1 -} - -// AssociateIamInstanceProfileRequest indicates an expected call of AssociateIamInstanceProfileRequest. -func (mr *MockEC2MockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2)(nil).AssociateIamInstanceProfileRequest), arg0) -} - -// AssociateIamInstanceProfileWithContext mocks base method. -func (m *MockEC2) AssociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.AssociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateIamInstanceProfileWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIamInstanceProfileWithContext indicates an expected call of AssociateIamInstanceProfileWithContext. -func (mr *MockEC2MockRecorder) AssociateIamInstanceProfileWithContext(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, "AssociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateIamInstanceProfileWithContext), varargs...) -} - -// AssociateInstanceEventWindow mocks base method. -func (m *MockEC2) AssociateInstanceEventWindow(arg0 *ec2.AssociateInstanceEventWindowInput) (*ec2.AssociateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateInstanceEventWindow", arg0) - ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateInstanceEventWindow indicates an expected call of AssociateInstanceEventWindow. -func (mr *MockEC2MockRecorder) AssociateInstanceEventWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindow", reflect.TypeOf((*MockEC2)(nil).AssociateInstanceEventWindow), arg0) -} - -// AssociateInstanceEventWindowRequest mocks base method. -func (m *MockEC2) AssociateInstanceEventWindowRequest(arg0 *ec2.AssociateInstanceEventWindowInput) (*request.Request, *ec2.AssociateInstanceEventWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateInstanceEventWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateInstanceEventWindowOutput) - return ret0, ret1 -} - -// AssociateInstanceEventWindowRequest indicates an expected call of AssociateInstanceEventWindowRequest. -func (mr *MockEC2MockRecorder) AssociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2)(nil).AssociateInstanceEventWindowRequest), arg0) -} - -// AssociateInstanceEventWindowWithContext mocks base method. -func (m *MockEC2) AssociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.AssociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.AssociateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateInstanceEventWindowWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateInstanceEventWindowWithContext indicates an expected call of AssociateInstanceEventWindowWithContext. -func (mr *MockEC2MockRecorder) AssociateInstanceEventWindowWithContext(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, "AssociateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateInstanceEventWindowWithContext), varargs...) -} - -// AssociateIpamByoasn mocks base method. -func (m *MockEC2) AssociateIpamByoasn(arg0 *ec2.AssociateIpamByoasnInput) (*ec2.AssociateIpamByoasnOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIpamByoasn", arg0) - ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIpamByoasn indicates an expected call of AssociateIpamByoasn. -func (mr *MockEC2MockRecorder) AssociateIpamByoasn(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasn", reflect.TypeOf((*MockEC2)(nil).AssociateIpamByoasn), arg0) -} - -// AssociateIpamByoasnRequest mocks base method. -func (m *MockEC2) AssociateIpamByoasnRequest(arg0 *ec2.AssociateIpamByoasnInput) (*request.Request, *ec2.AssociateIpamByoasnOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIpamByoasnRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateIpamByoasnOutput) - return ret0, ret1 -} - -// AssociateIpamByoasnRequest indicates an expected call of AssociateIpamByoasnRequest. -func (mr *MockEC2MockRecorder) AssociateIpamByoasnRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamByoasnRequest", reflect.TypeOf((*MockEC2)(nil).AssociateIpamByoasnRequest), arg0) -} - -// AssociateIpamByoasnWithContext mocks base method. -func (m *MockEC2) AssociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamByoasnInput, arg2 ...request.Option) (*ec2.AssociateIpamByoasnOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateIpamByoasnWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIpamByoasnWithContext indicates an expected call of AssociateIpamByoasnWithContext. -func (mr *MockEC2MockRecorder) AssociateIpamByoasnWithContext(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, "AssociateIpamByoasnWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateIpamByoasnWithContext), varargs...) -} - -// AssociateIpamResourceDiscovery mocks base method. -func (m *MockEC2) AssociateIpamResourceDiscovery(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*ec2.AssociateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIpamResourceDiscovery", arg0) - ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIpamResourceDiscovery indicates an expected call of AssociateIpamResourceDiscovery. -func (mr *MockEC2MockRecorder) AssociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2)(nil).AssociateIpamResourceDiscovery), arg0) -} - -// AssociateIpamResourceDiscoveryRequest mocks base method. -func (m *MockEC2) AssociateIpamResourceDiscoveryRequest(arg0 *ec2.AssociateIpamResourceDiscoveryInput) (*request.Request, *ec2.AssociateIpamResourceDiscoveryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateIpamResourceDiscoveryOutput) - return ret0, ret1 -} - -// AssociateIpamResourceDiscoveryRequest indicates an expected call of AssociateIpamResourceDiscoveryRequest. -func (mr *MockEC2MockRecorder) AssociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2)(nil).AssociateIpamResourceDiscoveryRequest), arg0) -} - -// AssociateIpamResourceDiscoveryWithContext mocks base method. -func (m *MockEC2) AssociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.AssociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.AssociateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateIpamResourceDiscoveryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateIpamResourceDiscoveryWithContext indicates an expected call of AssociateIpamResourceDiscoveryWithContext. -func (mr *MockEC2MockRecorder) AssociateIpamResourceDiscoveryWithContext(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, "AssociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateIpamResourceDiscoveryWithContext), varargs...) -} - -// AssociateNatGatewayAddress mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateNatGatewayAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddress", reflect.TypeOf((*MockEC2)(nil).AssociateNatGatewayAddress), arg0) -} - -// AssociateNatGatewayAddressRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2)(nil).AssociateNatGatewayAddressRequest), arg0) -} - -// AssociateNatGatewayAddressWithContext mocks base method. -func (m *MockEC2) AssociateNatGatewayAddressWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).AssociateNatGatewayAddressWithContext), varargs...) -} - -// AssociateRouteTable mocks base method. -func (m *MockEC2) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateRouteTable", arg0) - ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateRouteTable indicates an expected call of AssociateRouteTable. -func (mr *MockEC2MockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2)(nil).AssociateRouteTable), arg0) -} - -// AssociateRouteTableRequest mocks base method. -func (m *MockEC2) AssociateRouteTableRequest(arg0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateRouteTableOutput) - return ret0, ret1 -} - -// AssociateRouteTableRequest indicates an expected call of AssociateRouteTableRequest. -func (mr *MockEC2MockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).AssociateRouteTableRequest), arg0) -} - -// AssociateRouteTableWithContext mocks base method. -func (m *MockEC2) AssociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...request.Option) (*ec2.AssociateRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateRouteTableWithContext indicates an expected call of AssociateRouteTableWithContext. -func (mr *MockEC2MockRecorder) AssociateRouteTableWithContext(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, "AssociateRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateRouteTableWithContext), varargs...) -} - -// AssociateSubnetCidrBlock mocks base method. -func (m *MockEC2) AssociateSubnetCidrBlock(arg0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateSubnetCidrBlock", arg0) - ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateSubnetCidrBlock indicates an expected call of AssociateSubnetCidrBlock. -func (mr *MockEC2MockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2)(nil).AssociateSubnetCidrBlock), arg0) -} - -// AssociateSubnetCidrBlockRequest mocks base method. -func (m *MockEC2) AssociateSubnetCidrBlockRequest(arg0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateSubnetCidrBlockOutput) - return ret0, ret1 -} - -// AssociateSubnetCidrBlockRequest indicates an expected call of AssociateSubnetCidrBlockRequest. -func (mr *MockEC2MockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2)(nil).AssociateSubnetCidrBlockRequest), arg0) -} - -// AssociateSubnetCidrBlockWithContext mocks base method. -func (m *MockEC2) AssociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateSubnetCidrBlockWithContext indicates an expected call of AssociateSubnetCidrBlockWithContext. -func (mr *MockEC2MockRecorder) AssociateSubnetCidrBlockWithContext(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, "AssociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateSubnetCidrBlockWithContext), varargs...) -} - -// AssociateTransitGatewayMulticastDomain mocks base method. -func (m *MockEC2) AssociateTransitGatewayMulticastDomain(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomain", arg0) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayMulticastDomain indicates an expected call of AssociateTransitGatewayMulticastDomain. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayMulticastDomain), arg0) -} - -// AssociateTransitGatewayMulticastDomainRequest mocks base method. -func (m *MockEC2) AssociateTransitGatewayMulticastDomainRequest(arg0 *ec2.AssociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.AssociateTransitGatewayMulticastDomainOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateTransitGatewayMulticastDomainOutput) - return ret0, ret1 -} - -// AssociateTransitGatewayMulticastDomainRequest indicates an expected call of AssociateTransitGatewayMulticastDomainRequest. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayMulticastDomainRequest), arg0) -} - -// AssociateTransitGatewayMulticastDomainWithContext mocks base method. -func (m *MockEC2) AssociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateTransitGatewayMulticastDomainWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayMulticastDomainWithContext indicates an expected call of AssociateTransitGatewayMulticastDomainWithContext. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayMulticastDomainWithContext(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, "AssociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayMulticastDomainWithContext), varargs...) -} - -// AssociateTransitGatewayPolicyTable mocks base method. -func (m *MockEC2) AssociateTransitGatewayPolicyTable(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTable", arg0) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayPolicyTable indicates an expected call of AssociateTransitGatewayPolicyTable. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayPolicyTable), arg0) -} - -// AssociateTransitGatewayPolicyTableRequest mocks base method. -func (m *MockEC2) AssociateTransitGatewayPolicyTableRequest(arg0 *ec2.AssociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.AssociateTransitGatewayPolicyTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateTransitGatewayPolicyTableOutput) - return ret0, ret1 -} - -// AssociateTransitGatewayPolicyTableRequest indicates an expected call of AssociateTransitGatewayPolicyTableRequest. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayPolicyTableRequest), arg0) -} - -// AssociateTransitGatewayPolicyTableWithContext mocks base method. -func (m *MockEC2) AssociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateTransitGatewayPolicyTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayPolicyTableWithContext indicates an expected call of AssociateTransitGatewayPolicyTableWithContext. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayPolicyTableWithContext(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, "AssociateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayPolicyTableWithContext), varargs...) -} - -// AssociateTransitGatewayRouteTable mocks base method. -func (m *MockEC2) AssociateTransitGatewayRouteTable(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayRouteTable indicates an expected call of AssociateTransitGatewayRouteTable. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayRouteTable), arg0) -} - -// AssociateTransitGatewayRouteTableRequest mocks base method. -func (m *MockEC2) AssociateTransitGatewayRouteTableRequest(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateTransitGatewayRouteTableOutput) - return ret0, ret1 -} - -// AssociateTransitGatewayRouteTableRequest indicates an expected call of AssociateTransitGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayRouteTableRequest), arg0) -} - -// AssociateTransitGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) AssociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.AssociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateTransitGatewayRouteTableWithContext indicates an expected call of AssociateTransitGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) AssociateTransitGatewayRouteTableWithContext(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, "AssociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...) -} - -// AssociateTrunkInterface mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateTrunkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterface", reflect.TypeOf((*MockEC2)(nil).AssociateTrunkInterface), arg0) -} - -// AssociateTrunkInterfaceRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) AssociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).AssociateTrunkInterfaceRequest), arg0) -} - -// AssociateTrunkInterfaceWithContext mocks base method. -func (m *MockEC2) AssociateTrunkInterfaceWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).AssociateTrunkInterfaceWithContext), varargs...) -} - -// AssociateVpcCidrBlock mocks base method. -func (m *MockEC2) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", arg0) - ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock. -func (mr *MockEC2MockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2)(nil).AssociateVpcCidrBlock), arg0) -} - -// AssociateVpcCidrBlockRequest mocks base method. -func (m *MockEC2) AssociateVpcCidrBlockRequest(arg0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateVpcCidrBlockRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AssociateVpcCidrBlockOutput) - return ret0, ret1 -} - -// AssociateVpcCidrBlockRequest indicates an expected call of AssociateVpcCidrBlockRequest. -func (mr *MockEC2MockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2)(nil).AssociateVpcCidrBlockRequest), arg0) -} - -// AssociateVpcCidrBlockWithContext mocks base method. -func (m *MockEC2) AssociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateVpcCidrBlockWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateVpcCidrBlockWithContext indicates an expected call of AssociateVpcCidrBlockWithContext. -func (mr *MockEC2MockRecorder) AssociateVpcCidrBlockWithContext(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, "AssociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2)(nil).AssociateVpcCidrBlockWithContext), varargs...) -} - -// AttachClassicLinkVpc mocks base method. -func (m *MockEC2) AttachClassicLinkVpc(arg0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachClassicLinkVpc", arg0) - ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachClassicLinkVpc indicates an expected call of AttachClassicLinkVpc. -func (mr *MockEC2MockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2)(nil).AttachClassicLinkVpc), arg0) -} - -// AttachClassicLinkVpcRequest mocks base method. -func (m *MockEC2) AttachClassicLinkVpcRequest(arg0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachClassicLinkVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AttachClassicLinkVpcOutput) - return ret0, ret1 -} - -// AttachClassicLinkVpcRequest indicates an expected call of AttachClassicLinkVpcRequest. -func (mr *MockEC2MockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2)(nil).AttachClassicLinkVpcRequest), arg0) -} - -// AttachClassicLinkVpcWithContext mocks base method. -func (m *MockEC2) AttachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.AttachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachClassicLinkVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachClassicLinkVpcWithContext indicates an expected call of AttachClassicLinkVpcWithContext. -func (mr *MockEC2MockRecorder) AttachClassicLinkVpcWithContext(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, "AttachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2)(nil).AttachClassicLinkVpcWithContext), varargs...) -} - -// AttachInternetGateway mocks base method. -func (m *MockEC2) AttachInternetGateway(arg0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachInternetGateway indicates an expected call of AttachInternetGateway. -func (mr *MockEC2MockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2)(nil).AttachInternetGateway), arg0) -} - -// AttachInternetGatewayRequest mocks base method. -func (m *MockEC2) AttachInternetGatewayRequest(arg0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AttachInternetGatewayOutput) - return ret0, ret1 -} - -// AttachInternetGatewayRequest indicates an expected call of AttachInternetGatewayRequest. -func (mr *MockEC2MockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).AttachInternetGatewayRequest), arg0) -} - -// AttachInternetGatewayWithContext mocks base method. -func (m *MockEC2) AttachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...request.Option) (*ec2.AttachInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachInternetGatewayWithContext indicates an expected call of AttachInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) AttachInternetGatewayWithContext(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, "AttachInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).AttachInternetGatewayWithContext), varargs...) -} - -// AttachNetworkInterface mocks base method. -func (m *MockEC2) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0) - ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachNetworkInterface indicates an expected call of AttachNetworkInterface. -func (mr *MockEC2MockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2)(nil).AttachNetworkInterface), arg0) -} - -// AttachNetworkInterfaceRequest mocks base method. -func (m *MockEC2) AttachNetworkInterfaceRequest(arg0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachNetworkInterfaceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AttachNetworkInterfaceOutput) - return ret0, ret1 -} - -// AttachNetworkInterfaceRequest indicates an expected call of AttachNetworkInterfaceRequest. -func (mr *MockEC2MockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).AttachNetworkInterfaceRequest), arg0) -} - -// AttachNetworkInterfaceWithContext mocks base method. -func (m *MockEC2) AttachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.AttachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachNetworkInterfaceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachNetworkInterfaceWithContext indicates an expected call of AttachNetworkInterfaceWithContext. -func (mr *MockEC2MockRecorder) AttachNetworkInterfaceWithContext(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, "AttachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2)(nil).AttachNetworkInterfaceWithContext), varargs...) -} - -// AttachVerifiedAccessTrustProvider mocks base method. -func (m *MockEC2) AttachVerifiedAccessTrustProvider(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProvider", arg0) - ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVerifiedAccessTrustProvider indicates an expected call of AttachVerifiedAccessTrustProvider. -func (mr *MockEC2MockRecorder) AttachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2)(nil).AttachVerifiedAccessTrustProvider), arg0) -} - -// AttachVerifiedAccessTrustProviderRequest mocks base method. -func (m *MockEC2) AttachVerifiedAccessTrustProviderRequest(arg0 *ec2.AttachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.AttachVerifiedAccessTrustProviderOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AttachVerifiedAccessTrustProviderOutput) - return ret0, ret1 -} - -// AttachVerifiedAccessTrustProviderRequest indicates an expected call of AttachVerifiedAccessTrustProviderRequest. -func (mr *MockEC2MockRecorder) AttachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2)(nil).AttachVerifiedAccessTrustProviderRequest), arg0) -} - -// AttachVerifiedAccessTrustProviderWithContext mocks base method. -func (m *MockEC2) AttachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.AttachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.AttachVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachVerifiedAccessTrustProviderWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AttachVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVerifiedAccessTrustProviderWithContext indicates an expected call of AttachVerifiedAccessTrustProviderWithContext. -func (mr *MockEC2MockRecorder) AttachVerifiedAccessTrustProviderWithContext(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, "AttachVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2)(nil).AttachVerifiedAccessTrustProviderWithContext), varargs...) -} - -// AttachVolume mocks base method. -func (m *MockEC2) AttachVolume(arg0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVolume", arg0) - ret0, _ := ret[0].(*ec2.VolumeAttachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVolume indicates an expected call of AttachVolume. -func (mr *MockEC2MockRecorder) AttachVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2)(nil).AttachVolume), arg0) -} - -// AttachVolumeRequest mocks base method. -func (m *MockEC2) AttachVolumeRequest(arg0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.VolumeAttachment) - return ret0, ret1 -} - -// AttachVolumeRequest indicates an expected call of AttachVolumeRequest. -func (mr *MockEC2MockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2)(nil).AttachVolumeRequest), arg0) -} - -// AttachVolumeWithContext mocks base method. -func (m *MockEC2) AttachVolumeWithContext(arg0 context.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.VolumeAttachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVolumeWithContext indicates an expected call of AttachVolumeWithContext. -func (mr *MockEC2MockRecorder) AttachVolumeWithContext(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, "AttachVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).AttachVolumeWithContext), varargs...) -} - -// AttachVpnGateway mocks base method. -func (m *MockEC2) AttachVpnGateway(arg0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVpnGateway", arg0) - ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVpnGateway indicates an expected call of AttachVpnGateway. -func (mr *MockEC2MockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2)(nil).AttachVpnGateway), arg0) -} - -// AttachVpnGatewayRequest mocks base method. -func (m *MockEC2) AttachVpnGatewayRequest(arg0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AttachVpnGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AttachVpnGatewayOutput) - return ret0, ret1 -} - -// AttachVpnGatewayRequest indicates an expected call of AttachVpnGatewayRequest. -func (mr *MockEC2MockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2)(nil).AttachVpnGatewayRequest), arg0) -} - -// AttachVpnGatewayWithContext mocks base method. -func (m *MockEC2) AttachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.AttachVpnGatewayInput, arg2 ...request.Option) (*ec2.AttachVpnGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AttachVpnGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AttachVpnGatewayWithContext indicates an expected call of AttachVpnGatewayWithContext. -func (mr *MockEC2MockRecorder) AttachVpnGatewayWithContext(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, "AttachVpnGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).AttachVpnGatewayWithContext), varargs...) -} - -// AuthorizeClientVpnIngress mocks base method. -func (m *MockEC2) AuthorizeClientVpnIngress(arg0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeClientVpnIngress", arg0) - ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeClientVpnIngress indicates an expected call of AuthorizeClientVpnIngress. -func (mr *MockEC2MockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2)(nil).AuthorizeClientVpnIngress), arg0) -} - -// AuthorizeClientVpnIngressRequest mocks base method. -func (m *MockEC2) AuthorizeClientVpnIngressRequest(arg0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AuthorizeClientVpnIngressOutput) - return ret0, ret1 -} - -// AuthorizeClientVpnIngressRequest indicates an expected call of AuthorizeClientVpnIngressRequest. -func (mr *MockEC2MockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2)(nil).AuthorizeClientVpnIngressRequest), arg0) -} - -// AuthorizeClientVpnIngressWithContext mocks base method. -func (m *MockEC2) AuthorizeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeClientVpnIngressInput, arg2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeClientVpnIngressWithContext indicates an expected call of AuthorizeClientVpnIngressWithContext. -func (mr *MockEC2MockRecorder) AuthorizeClientVpnIngressWithContext(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, "AuthorizeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2)(nil).AuthorizeClientVpnIngressWithContext), varargs...) -} - -// AuthorizeSecurityGroupEgress mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupEgress(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0) - ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupEgress), arg0) -} - -// AuthorizeSecurityGroupEgressRequest mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupEgressRequest(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupEgressOutput) - return ret0, ret1 -} - -// AuthorizeSecurityGroupEgressRequest indicates an expected call of AuthorizeSecurityGroupEgressRequest. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupEgressRequest), arg0) -} - -// AuthorizeSecurityGroupEgressWithContext mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeSecurityGroupEgressWithContext indicates an expected call of AuthorizeSecurityGroupEgressWithContext. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupEgressWithContext(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, "AuthorizeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupEgressWithContext), varargs...) -} - -// AuthorizeSecurityGroupIngress mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupIngress(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", arg0) - ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupIngress), arg0) -} - -// AuthorizeSecurityGroupIngressRequest mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupIngressRequest(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupIngressOutput) - return ret0, ret1 -} - -// AuthorizeSecurityGroupIngressRequest indicates an expected call of AuthorizeSecurityGroupIngressRequest. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupIngressRequest), arg0) -} - -// AuthorizeSecurityGroupIngressWithContext mocks base method. -func (m *MockEC2) AuthorizeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AuthorizeSecurityGroupIngressWithContext indicates an expected call of AuthorizeSecurityGroupIngressWithContext. -func (mr *MockEC2MockRecorder) AuthorizeSecurityGroupIngressWithContext(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, "AuthorizeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2)(nil).AuthorizeSecurityGroupIngressWithContext), varargs...) -} - -// BundleInstance mocks base method. -func (m *MockEC2) BundleInstance(arg0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BundleInstance", arg0) - ret0, _ := ret[0].(*ec2.BundleInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BundleInstance indicates an expected call of BundleInstance. -func (mr *MockEC2MockRecorder) BundleInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2)(nil).BundleInstance), arg0) -} - -// BundleInstanceRequest mocks base method. -func (m *MockEC2) BundleInstanceRequest(arg0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "BundleInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.BundleInstanceOutput) - return ret0, ret1 -} - -// BundleInstanceRequest indicates an expected call of BundleInstanceRequest. -func (mr *MockEC2MockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2)(nil).BundleInstanceRequest), arg0) -} - -// BundleInstanceWithContext mocks base method. -func (m *MockEC2) BundleInstanceWithContext(arg0 context.Context, arg1 *ec2.BundleInstanceInput, arg2 ...request.Option) (*ec2.BundleInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "BundleInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.BundleInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// BundleInstanceWithContext indicates an expected call of BundleInstanceWithContext. -func (mr *MockEC2MockRecorder) BundleInstanceWithContext(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, "BundleInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).BundleInstanceWithContext), varargs...) -} - -// CancelBundleTask mocks base method. -func (m *MockEC2) CancelBundleTask(arg0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelBundleTask", arg0) - ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelBundleTask indicates an expected call of CancelBundleTask. -func (mr *MockEC2MockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2)(nil).CancelBundleTask), arg0) -} - -// CancelBundleTaskRequest mocks base method. -func (m *MockEC2) CancelBundleTaskRequest(arg0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelBundleTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelBundleTaskOutput) - return ret0, ret1 -} - -// CancelBundleTaskRequest indicates an expected call of CancelBundleTaskRequest. -func (mr *MockEC2MockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2)(nil).CancelBundleTaskRequest), arg0) -} - -// CancelBundleTaskWithContext mocks base method. -func (m *MockEC2) CancelBundleTaskWithContext(arg0 context.Context, arg1 *ec2.CancelBundleTaskInput, arg2 ...request.Option) (*ec2.CancelBundleTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelBundleTaskWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelBundleTaskWithContext indicates an expected call of CancelBundleTaskWithContext. -func (mr *MockEC2MockRecorder) CancelBundleTaskWithContext(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, "CancelBundleTaskWithContext", reflect.TypeOf((*MockEC2)(nil).CancelBundleTaskWithContext), varargs...) -} - -// CancelCapacityReservation mocks base method. -func (m *MockEC2) CancelCapacityReservation(arg0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0) - ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCapacityReservation indicates an expected call of CancelCapacityReservation. -func (mr *MockEC2MockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservation), arg0) -} - -// CancelCapacityReservationFleets mocks base method. -func (m *MockEC2) CancelCapacityReservationFleets(arg0 *ec2.CancelCapacityReservationFleetsInput) (*ec2.CancelCapacityReservationFleetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCapacityReservationFleets", arg0) - ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCapacityReservationFleets indicates an expected call of CancelCapacityReservationFleets. -func (mr *MockEC2MockRecorder) CancelCapacityReservationFleets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleets", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservationFleets), arg0) -} - -// CancelCapacityReservationFleetsRequest mocks base method. -func (m *MockEC2) CancelCapacityReservationFleetsRequest(arg0 *ec2.CancelCapacityReservationFleetsInput) (*request.Request, *ec2.CancelCapacityReservationFleetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelCapacityReservationFleetsOutput) - return ret0, ret1 -} - -// CancelCapacityReservationFleetsRequest indicates an expected call of CancelCapacityReservationFleetsRequest. -func (mr *MockEC2MockRecorder) CancelCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservationFleetsRequest), arg0) -} - -// CancelCapacityReservationFleetsWithContext mocks base method. -func (m *MockEC2) CancelCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationFleetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelCapacityReservationFleetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelCapacityReservationFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCapacityReservationFleetsWithContext indicates an expected call of CancelCapacityReservationFleetsWithContext. -func (mr *MockEC2MockRecorder) CancelCapacityReservationFleetsWithContext(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, "CancelCapacityReservationFleetsWithContext", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservationFleetsWithContext), varargs...) -} - -// CancelCapacityReservationRequest mocks base method. -func (m *MockEC2) CancelCapacityReservationRequest(arg0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelCapacityReservationOutput) - return ret0, ret1 -} - -// CancelCapacityReservationRequest indicates an expected call of CancelCapacityReservationRequest. -func (mr *MockEC2MockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservationRequest), arg0) -} - -// CancelCapacityReservationWithContext mocks base method. -func (m *MockEC2) CancelCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CancelCapacityReservationInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelCapacityReservationWithContext indicates an expected call of CancelCapacityReservationWithContext. -func (mr *MockEC2MockRecorder) CancelCapacityReservationWithContext(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, "CancelCapacityReservationWithContext", reflect.TypeOf((*MockEC2)(nil).CancelCapacityReservationWithContext), varargs...) -} - -// CancelConversionTask mocks base method. -func (m *MockEC2) CancelConversionTask(arg0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelConversionTask", arg0) - ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelConversionTask indicates an expected call of CancelConversionTask. -func (mr *MockEC2MockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2)(nil).CancelConversionTask), arg0) -} - -// CancelConversionTaskRequest mocks base method. -func (m *MockEC2) CancelConversionTaskRequest(arg0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelConversionTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelConversionTaskOutput) - return ret0, ret1 -} - -// CancelConversionTaskRequest indicates an expected call of CancelConversionTaskRequest. -func (mr *MockEC2MockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2)(nil).CancelConversionTaskRequest), arg0) -} - -// CancelConversionTaskWithContext mocks base method. -func (m *MockEC2) CancelConversionTaskWithContext(arg0 context.Context, arg1 *ec2.CancelConversionTaskInput, arg2 ...request.Option) (*ec2.CancelConversionTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelConversionTaskWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelConversionTaskWithContext indicates an expected call of CancelConversionTaskWithContext. -func (mr *MockEC2MockRecorder) CancelConversionTaskWithContext(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, "CancelConversionTaskWithContext", reflect.TypeOf((*MockEC2)(nil).CancelConversionTaskWithContext), varargs...) -} - -// CancelExportTask mocks base method. -func (m *MockEC2) CancelExportTask(arg0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelExportTask", arg0) - ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelExportTask indicates an expected call of CancelExportTask. -func (mr *MockEC2MockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2)(nil).CancelExportTask), arg0) -} - -// CancelExportTaskRequest mocks base method. -func (m *MockEC2) CancelExportTaskRequest(arg0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelExportTaskOutput) - return ret0, ret1 -} - -// CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest. -func (mr *MockEC2MockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2)(nil).CancelExportTaskRequest), arg0) -} - -// CancelExportTaskWithContext mocks base method. -func (m *MockEC2) CancelExportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelExportTaskInput, arg2 ...request.Option) (*ec2.CancelExportTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelExportTaskWithContext indicates an expected call of CancelExportTaskWithContext. -func (mr *MockEC2MockRecorder) CancelExportTaskWithContext(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, "CancelExportTaskWithContext", reflect.TypeOf((*MockEC2)(nil).CancelExportTaskWithContext), varargs...) -} - -// CancelImageLaunchPermission mocks base method. -func (m *MockEC2) CancelImageLaunchPermission(arg0 *ec2.CancelImageLaunchPermissionInput) (*ec2.CancelImageLaunchPermissionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelImageLaunchPermission", arg0) - ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelImageLaunchPermission indicates an expected call of CancelImageLaunchPermission. -func (mr *MockEC2MockRecorder) CancelImageLaunchPermission(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermission", reflect.TypeOf((*MockEC2)(nil).CancelImageLaunchPermission), arg0) -} - -// CancelImageLaunchPermissionRequest mocks base method. -func (m *MockEC2) CancelImageLaunchPermissionRequest(arg0 *ec2.CancelImageLaunchPermissionInput) (*request.Request, *ec2.CancelImageLaunchPermissionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelImageLaunchPermissionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelImageLaunchPermissionOutput) - return ret0, ret1 -} - -// CancelImageLaunchPermissionRequest indicates an expected call of CancelImageLaunchPermissionRequest. -func (mr *MockEC2MockRecorder) CancelImageLaunchPermissionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImageLaunchPermissionRequest", reflect.TypeOf((*MockEC2)(nil).CancelImageLaunchPermissionRequest), arg0) -} - -// CancelImageLaunchPermissionWithContext mocks base method. -func (m *MockEC2) CancelImageLaunchPermissionWithContext(arg0 context.Context, arg1 *ec2.CancelImageLaunchPermissionInput, arg2 ...request.Option) (*ec2.CancelImageLaunchPermissionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelImageLaunchPermissionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelImageLaunchPermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelImageLaunchPermissionWithContext indicates an expected call of CancelImageLaunchPermissionWithContext. -func (mr *MockEC2MockRecorder) CancelImageLaunchPermissionWithContext(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, "CancelImageLaunchPermissionWithContext", reflect.TypeOf((*MockEC2)(nil).CancelImageLaunchPermissionWithContext), varargs...) -} - -// CancelImportTask mocks base method. -func (m *MockEC2) CancelImportTask(arg0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelImportTask", arg0) - ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelImportTask indicates an expected call of CancelImportTask. -func (mr *MockEC2MockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2)(nil).CancelImportTask), arg0) -} - -// CancelImportTaskRequest mocks base method. -func (m *MockEC2) CancelImportTaskRequest(arg0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelImportTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelImportTaskOutput) - return ret0, ret1 -} - -// CancelImportTaskRequest indicates an expected call of CancelImportTaskRequest. -func (mr *MockEC2MockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2)(nil).CancelImportTaskRequest), arg0) -} - -// CancelImportTaskWithContext mocks base method. -func (m *MockEC2) CancelImportTaskWithContext(arg0 context.Context, arg1 *ec2.CancelImportTaskInput, arg2 ...request.Option) (*ec2.CancelImportTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelImportTaskWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelImportTaskWithContext indicates an expected call of CancelImportTaskWithContext. -func (mr *MockEC2MockRecorder) CancelImportTaskWithContext(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, "CancelImportTaskWithContext", reflect.TypeOf((*MockEC2)(nil).CancelImportTaskWithContext), varargs...) -} - -// CancelReservedInstancesListing mocks base method. -func (m *MockEC2) CancelReservedInstancesListing(arg0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelReservedInstancesListing", arg0) - ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelReservedInstancesListing indicates an expected call of CancelReservedInstancesListing. -func (mr *MockEC2MockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2)(nil).CancelReservedInstancesListing), arg0) -} - -// CancelReservedInstancesListingRequest mocks base method. -func (m *MockEC2) CancelReservedInstancesListingRequest(arg0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelReservedInstancesListingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelReservedInstancesListingOutput) - return ret0, ret1 -} - -// CancelReservedInstancesListingRequest indicates an expected call of CancelReservedInstancesListingRequest. -func (mr *MockEC2MockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2)(nil).CancelReservedInstancesListingRequest), arg0) -} - -// CancelReservedInstancesListingWithContext mocks base method. -func (m *MockEC2) CancelReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CancelReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelReservedInstancesListingWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelReservedInstancesListingWithContext indicates an expected call of CancelReservedInstancesListingWithContext. -func (mr *MockEC2MockRecorder) CancelReservedInstancesListingWithContext(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, "CancelReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2)(nil).CancelReservedInstancesListingWithContext), varargs...) -} - -// CancelSpotFleetRequests mocks base method. -func (m *MockEC2) CancelSpotFleetRequests(arg0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelSpotFleetRequests", arg0) - ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelSpotFleetRequests indicates an expected call of CancelSpotFleetRequests. -func (mr *MockEC2MockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2)(nil).CancelSpotFleetRequests), arg0) -} - -// CancelSpotFleetRequestsRequest mocks base method. -func (m *MockEC2) CancelSpotFleetRequestsRequest(arg0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelSpotFleetRequestsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelSpotFleetRequestsOutput) - return ret0, ret1 -} - -// CancelSpotFleetRequestsRequest indicates an expected call of CancelSpotFleetRequestsRequest. -func (mr *MockEC2MockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2)(nil).CancelSpotFleetRequestsRequest), arg0) -} - -// CancelSpotFleetRequestsWithContext mocks base method. -func (m *MockEC2) CancelSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelSpotFleetRequestsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelSpotFleetRequestsWithContext indicates an expected call of CancelSpotFleetRequestsWithContext. -func (mr *MockEC2MockRecorder) CancelSpotFleetRequestsWithContext(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, "CancelSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2)(nil).CancelSpotFleetRequestsWithContext), varargs...) -} - -// CancelSpotInstanceRequests mocks base method. -func (m *MockEC2) CancelSpotInstanceRequests(arg0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelSpotInstanceRequests", arg0) - ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelSpotInstanceRequests indicates an expected call of CancelSpotInstanceRequests. -func (mr *MockEC2MockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2)(nil).CancelSpotInstanceRequests), arg0) -} - -// CancelSpotInstanceRequestsRequest mocks base method. -func (m *MockEC2) CancelSpotInstanceRequestsRequest(arg0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CancelSpotInstanceRequestsOutput) - return ret0, ret1 -} - -// CancelSpotInstanceRequestsRequest indicates an expected call of CancelSpotInstanceRequestsRequest. -func (mr *MockEC2MockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2)(nil).CancelSpotInstanceRequestsRequest), arg0) -} - -// CancelSpotInstanceRequestsWithContext mocks base method. -func (m *MockEC2) CancelSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.CancelSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CancelSpotInstanceRequestsWithContext indicates an expected call of CancelSpotInstanceRequestsWithContext. -func (mr *MockEC2MockRecorder) CancelSpotInstanceRequestsWithContext(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, "CancelSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2)(nil).CancelSpotInstanceRequestsWithContext), varargs...) -} - -// ConfirmProductInstance mocks base method. -func (m *MockEC2) ConfirmProductInstance(arg0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfirmProductInstance", arg0) - ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ConfirmProductInstance indicates an expected call of ConfirmProductInstance. -func (mr *MockEC2MockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2)(nil).ConfirmProductInstance), arg0) -} - -// ConfirmProductInstanceRequest mocks base method. -func (m *MockEC2) ConfirmProductInstanceRequest(arg0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ConfirmProductInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ConfirmProductInstanceOutput) - return ret0, ret1 -} - -// ConfirmProductInstanceRequest indicates an expected call of ConfirmProductInstanceRequest. -func (mr *MockEC2MockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2)(nil).ConfirmProductInstanceRequest), arg0) -} - -// ConfirmProductInstanceWithContext mocks base method. -func (m *MockEC2) ConfirmProductInstanceWithContext(arg0 context.Context, arg1 *ec2.ConfirmProductInstanceInput, arg2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ConfirmProductInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ConfirmProductInstanceWithContext indicates an expected call of ConfirmProductInstanceWithContext. -func (mr *MockEC2MockRecorder) ConfirmProductInstanceWithContext(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, "ConfirmProductInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).ConfirmProductInstanceWithContext), varargs...) -} - -// CopyFpgaImage mocks base method. -func (m *MockEC2) CopyFpgaImage(arg0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopyFpgaImage", arg0) - ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopyFpgaImage indicates an expected call of CopyFpgaImage. -func (mr *MockEC2MockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2)(nil).CopyFpgaImage), arg0) -} - -// CopyFpgaImageRequest mocks base method. -func (m *MockEC2) CopyFpgaImageRequest(arg0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopyFpgaImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CopyFpgaImageOutput) - return ret0, ret1 -} - -// CopyFpgaImageRequest indicates an expected call of CopyFpgaImageRequest. -func (mr *MockEC2MockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2)(nil).CopyFpgaImageRequest), arg0) -} - -// CopyFpgaImageWithContext mocks base method. -func (m *MockEC2) CopyFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CopyFpgaImageInput, arg2 ...request.Option) (*ec2.CopyFpgaImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CopyFpgaImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopyFpgaImageWithContext indicates an expected call of CopyFpgaImageWithContext. -func (mr *MockEC2MockRecorder) CopyFpgaImageWithContext(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, "CopyFpgaImageWithContext", reflect.TypeOf((*MockEC2)(nil).CopyFpgaImageWithContext), varargs...) -} - -// CopyImage mocks base method. -func (m *MockEC2) CopyImage(arg0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopyImage", arg0) - ret0, _ := ret[0].(*ec2.CopyImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopyImage indicates an expected call of CopyImage. -func (mr *MockEC2MockRecorder) CopyImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2)(nil).CopyImage), arg0) -} - -// CopyImageRequest mocks base method. -func (m *MockEC2) CopyImageRequest(arg0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopyImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CopyImageOutput) - return ret0, ret1 -} - -// CopyImageRequest indicates an expected call of CopyImageRequest. -func (mr *MockEC2MockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2)(nil).CopyImageRequest), arg0) -} - -// CopyImageWithContext mocks base method. -func (m *MockEC2) CopyImageWithContext(arg0 context.Context, arg1 *ec2.CopyImageInput, arg2 ...request.Option) (*ec2.CopyImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CopyImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CopyImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopyImageWithContext indicates an expected call of CopyImageWithContext. -func (mr *MockEC2MockRecorder) CopyImageWithContext(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, "CopyImageWithContext", reflect.TypeOf((*MockEC2)(nil).CopyImageWithContext), varargs...) -} - -// CopySnapshot mocks base method. -func (m *MockEC2) CopySnapshot(arg0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopySnapshot", arg0) - ret0, _ := ret[0].(*ec2.CopySnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopySnapshot indicates an expected call of CopySnapshot. -func (mr *MockEC2MockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2)(nil).CopySnapshot), arg0) -} - -// CopySnapshotRequest mocks base method. -func (m *MockEC2) CopySnapshotRequest(arg0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CopySnapshotOutput) - return ret0, ret1 -} - -// CopySnapshotRequest indicates an expected call of CopySnapshotRequest. -func (mr *MockEC2MockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2)(nil).CopySnapshotRequest), arg0) -} - -// CopySnapshotWithContext mocks base method. -func (m *MockEC2) CopySnapshotWithContext(arg0 context.Context, arg1 *ec2.CopySnapshotInput, arg2 ...request.Option) (*ec2.CopySnapshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CopySnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext. -func (mr *MockEC2MockRecorder) CopySnapshotWithContext(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, "CopySnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).CopySnapshotWithContext), varargs...) -} - -// CreateCapacityReservation mocks base method. -func (m *MockEC2) CreateCapacityReservation(arg0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0) - ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCapacityReservation indicates an expected call of CreateCapacityReservation. -func (mr *MockEC2MockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservation), arg0) -} - -// CreateCapacityReservationFleet mocks base method. -func (m *MockEC2) CreateCapacityReservationFleet(arg0 *ec2.CreateCapacityReservationFleetInput) (*ec2.CreateCapacityReservationFleetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCapacityReservationFleet", arg0) - ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCapacityReservationFleet indicates an expected call of CreateCapacityReservationFleet. -func (mr *MockEC2MockRecorder) CreateCapacityReservationFleet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleet", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservationFleet), arg0) -} - -// CreateCapacityReservationFleetRequest mocks base method. -func (m *MockEC2) CreateCapacityReservationFleetRequest(arg0 *ec2.CreateCapacityReservationFleetInput) (*request.Request, *ec2.CreateCapacityReservationFleetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCapacityReservationFleetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCapacityReservationFleetOutput) - return ret0, ret1 -} - -// CreateCapacityReservationFleetRequest indicates an expected call of CreateCapacityReservationFleetRequest. -func (mr *MockEC2MockRecorder) CreateCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservationFleetRequest), arg0) -} - -// CreateCapacityReservationFleetWithContext mocks base method. -func (m *MockEC2) CreateCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationFleetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCapacityReservationFleetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCapacityReservationFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCapacityReservationFleetWithContext indicates an expected call of CreateCapacityReservationFleetWithContext. -func (mr *MockEC2MockRecorder) CreateCapacityReservationFleetWithContext(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, "CreateCapacityReservationFleetWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservationFleetWithContext), varargs...) -} - -// CreateCapacityReservationRequest mocks base method. -func (m *MockEC2) CreateCapacityReservationRequest(arg0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCapacityReservationOutput) - return ret0, ret1 -} - -// CreateCapacityReservationRequest indicates an expected call of CreateCapacityReservationRequest. -func (mr *MockEC2MockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservationRequest), arg0) -} - -// CreateCapacityReservationWithContext mocks base method. -func (m *MockEC2) CreateCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.CreateCapacityReservationInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCapacityReservationWithContext indicates an expected call of CreateCapacityReservationWithContext. -func (mr *MockEC2MockRecorder) CreateCapacityReservationWithContext(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, "CreateCapacityReservationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCapacityReservationWithContext), varargs...) -} - -// CreateCarrierGateway mocks base method. -func (m *MockEC2) CreateCarrierGateway(arg0 *ec2.CreateCarrierGatewayInput) (*ec2.CreateCarrierGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCarrierGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCarrierGateway indicates an expected call of CreateCarrierGateway. -func (mr *MockEC2MockRecorder) CreateCarrierGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGateway", reflect.TypeOf((*MockEC2)(nil).CreateCarrierGateway), arg0) -} - -// CreateCarrierGatewayRequest mocks base method. -func (m *MockEC2) CreateCarrierGatewayRequest(arg0 *ec2.CreateCarrierGatewayInput) (*request.Request, *ec2.CreateCarrierGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCarrierGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCarrierGatewayOutput) - return ret0, ret1 -} - -// CreateCarrierGatewayRequest indicates an expected call of CreateCarrierGatewayRequest. -func (mr *MockEC2MockRecorder) CreateCarrierGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCarrierGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateCarrierGatewayRequest), arg0) -} - -// CreateCarrierGatewayWithContext mocks base method. -func (m *MockEC2) CreateCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCarrierGatewayInput, arg2 ...request.Option) (*ec2.CreateCarrierGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCarrierGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCarrierGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCarrierGatewayWithContext indicates an expected call of CreateCarrierGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateCarrierGatewayWithContext(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, "CreateCarrierGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCarrierGatewayWithContext), varargs...) -} - -// CreateClientVpnEndpoint mocks base method. -func (m *MockEC2) CreateClientVpnEndpoint(arg0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateClientVpnEndpoint", arg0) - ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateClientVpnEndpoint indicates an expected call of CreateClientVpnEndpoint. -func (mr *MockEC2MockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnEndpoint), arg0) -} - -// CreateClientVpnEndpointRequest mocks base method. -func (m *MockEC2) CreateClientVpnEndpointRequest(arg0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateClientVpnEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateClientVpnEndpointOutput) - return ret0, ret1 -} - -// CreateClientVpnEndpointRequest indicates an expected call of CreateClientVpnEndpointRequest. -func (mr *MockEC2MockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnEndpointRequest), arg0) -} - -// CreateClientVpnEndpointWithContext mocks base method. -func (m *MockEC2) CreateClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnEndpointInput, arg2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateClientVpnEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateClientVpnEndpointWithContext indicates an expected call of CreateClientVpnEndpointWithContext. -func (mr *MockEC2MockRecorder) CreateClientVpnEndpointWithContext(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, "CreateClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnEndpointWithContext), varargs...) -} - -// CreateClientVpnRoute mocks base method. -func (m *MockEC2) CreateClientVpnRoute(arg0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateClientVpnRoute", arg0) - ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateClientVpnRoute indicates an expected call of CreateClientVpnRoute. -func (mr *MockEC2MockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnRoute), arg0) -} - -// CreateClientVpnRouteRequest mocks base method. -func (m *MockEC2) CreateClientVpnRouteRequest(arg0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateClientVpnRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateClientVpnRouteOutput) - return ret0, ret1 -} - -// CreateClientVpnRouteRequest indicates an expected call of CreateClientVpnRouteRequest. -func (mr *MockEC2MockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnRouteRequest), arg0) -} - -// CreateClientVpnRouteWithContext mocks base method. -func (m *MockEC2) CreateClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.CreateClientVpnRouteInput, arg2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateClientVpnRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateClientVpnRouteWithContext indicates an expected call of CreateClientVpnRouteWithContext. -func (mr *MockEC2MockRecorder) CreateClientVpnRouteWithContext(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, "CreateClientVpnRouteWithContext", reflect.TypeOf((*MockEC2)(nil).CreateClientVpnRouteWithContext), varargs...) -} - -// CreateCoipCidr mocks base method. -func (m *MockEC2) CreateCoipCidr(arg0 *ec2.CreateCoipCidrInput) (*ec2.CreateCoipCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCoipCidr", arg0) - ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCoipCidr indicates an expected call of CreateCoipCidr. -func (mr *MockEC2MockRecorder) CreateCoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidr", reflect.TypeOf((*MockEC2)(nil).CreateCoipCidr), arg0) -} - -// CreateCoipCidrRequest mocks base method. -func (m *MockEC2) CreateCoipCidrRequest(arg0 *ec2.CreateCoipCidrInput) (*request.Request, *ec2.CreateCoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCoipCidrOutput) - return ret0, ret1 -} - -// CreateCoipCidrRequest indicates an expected call of CreateCoipCidrRequest. -func (mr *MockEC2MockRecorder) CreateCoipCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).CreateCoipCidrRequest), arg0) -} - -// CreateCoipCidrWithContext mocks base method. -func (m *MockEC2) CreateCoipCidrWithContext(arg0 context.Context, arg1 *ec2.CreateCoipCidrInput, arg2 ...request.Option) (*ec2.CreateCoipCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCoipCidrWithContext indicates an expected call of CreateCoipCidrWithContext. -func (mr *MockEC2MockRecorder) CreateCoipCidrWithContext(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, "CreateCoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCoipCidrWithContext), varargs...) -} - -// CreateCoipPool mocks base method. -func (m *MockEC2) CreateCoipPool(arg0 *ec2.CreateCoipPoolInput) (*ec2.CreateCoipPoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCoipPool", arg0) - ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCoipPool indicates an expected call of CreateCoipPool. -func (mr *MockEC2MockRecorder) CreateCoipPool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPool", reflect.TypeOf((*MockEC2)(nil).CreateCoipPool), arg0) -} - -// CreateCoipPoolRequest mocks base method. -func (m *MockEC2) CreateCoipPoolRequest(arg0 *ec2.CreateCoipPoolInput) (*request.Request, *ec2.CreateCoipPoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCoipPoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCoipPoolOutput) - return ret0, ret1 -} - -// CreateCoipPoolRequest indicates an expected call of CreateCoipPoolRequest. -func (mr *MockEC2MockRecorder) CreateCoipPoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCoipPoolRequest", reflect.TypeOf((*MockEC2)(nil).CreateCoipPoolRequest), arg0) -} - -// CreateCoipPoolWithContext mocks base method. -func (m *MockEC2) CreateCoipPoolWithContext(arg0 context.Context, arg1 *ec2.CreateCoipPoolInput, arg2 ...request.Option) (*ec2.CreateCoipPoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCoipPoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCoipPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCoipPoolWithContext indicates an expected call of CreateCoipPoolWithContext. -func (mr *MockEC2MockRecorder) CreateCoipPoolWithContext(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, "CreateCoipPoolWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCoipPoolWithContext), varargs...) -} - -// CreateCustomerGateway mocks base method. -func (m *MockEC2) CreateCustomerGateway(arg0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCustomerGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCustomerGateway indicates an expected call of CreateCustomerGateway. -func (mr *MockEC2MockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2)(nil).CreateCustomerGateway), arg0) -} - -// CreateCustomerGatewayRequest mocks base method. -func (m *MockEC2) CreateCustomerGatewayRequest(arg0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateCustomerGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateCustomerGatewayOutput) - return ret0, ret1 -} - -// CreateCustomerGatewayRequest indicates an expected call of CreateCustomerGatewayRequest. -func (mr *MockEC2MockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateCustomerGatewayRequest), arg0) -} - -// CreateCustomerGatewayWithContext mocks base method. -func (m *MockEC2) CreateCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateCustomerGatewayInput, arg2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateCustomerGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateCustomerGatewayWithContext indicates an expected call of CreateCustomerGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateCustomerGatewayWithContext(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, "CreateCustomerGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateCustomerGatewayWithContext), varargs...) -} - -// CreateDefaultSubnet mocks base method. -func (m *MockEC2) CreateDefaultSubnet(arg0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDefaultSubnet", arg0) - ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDefaultSubnet indicates an expected call of CreateDefaultSubnet. -func (mr *MockEC2MockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2)(nil).CreateDefaultSubnet), arg0) -} - -// CreateDefaultSubnetRequest mocks base method. -func (m *MockEC2) CreateDefaultSubnetRequest(arg0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDefaultSubnetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateDefaultSubnetOutput) - return ret0, ret1 -} - -// CreateDefaultSubnetRequest indicates an expected call of CreateDefaultSubnetRequest. -func (mr *MockEC2MockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2)(nil).CreateDefaultSubnetRequest), arg0) -} - -// CreateDefaultSubnetWithContext mocks base method. -func (m *MockEC2) CreateDefaultSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultSubnetInput, arg2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateDefaultSubnetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDefaultSubnetWithContext indicates an expected call of CreateDefaultSubnetWithContext. -func (mr *MockEC2MockRecorder) CreateDefaultSubnetWithContext(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, "CreateDefaultSubnetWithContext", reflect.TypeOf((*MockEC2)(nil).CreateDefaultSubnetWithContext), varargs...) -} - -// CreateDefaultVpc mocks base method. -func (m *MockEC2) CreateDefaultVpc(arg0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDefaultVpc", arg0) - ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDefaultVpc indicates an expected call of CreateDefaultVpc. -func (mr *MockEC2MockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2)(nil).CreateDefaultVpc), arg0) -} - -// CreateDefaultVpcRequest mocks base method. -func (m *MockEC2) CreateDefaultVpcRequest(arg0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDefaultVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateDefaultVpcOutput) - return ret0, ret1 -} - -// CreateDefaultVpcRequest indicates an expected call of CreateDefaultVpcRequest. -func (mr *MockEC2MockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2)(nil).CreateDefaultVpcRequest), arg0) -} - -// CreateDefaultVpcWithContext mocks base method. -func (m *MockEC2) CreateDefaultVpcWithContext(arg0 context.Context, arg1 *ec2.CreateDefaultVpcInput, arg2 ...request.Option) (*ec2.CreateDefaultVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateDefaultVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDefaultVpcWithContext indicates an expected call of CreateDefaultVpcWithContext. -func (mr *MockEC2MockRecorder) CreateDefaultVpcWithContext(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, "CreateDefaultVpcWithContext", reflect.TypeOf((*MockEC2)(nil).CreateDefaultVpcWithContext), varargs...) -} - -// CreateDhcpOptions mocks base method. -func (m *MockEC2) CreateDhcpOptions(arg0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDhcpOptions", arg0) - ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDhcpOptions indicates an expected call of CreateDhcpOptions. -func (mr *MockEC2MockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2)(nil).CreateDhcpOptions), arg0) -} - -// CreateDhcpOptionsRequest mocks base method. -func (m *MockEC2) CreateDhcpOptionsRequest(arg0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateDhcpOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateDhcpOptionsOutput) - return ret0, ret1 -} - -// CreateDhcpOptionsRequest indicates an expected call of CreateDhcpOptionsRequest. -func (mr *MockEC2MockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2)(nil).CreateDhcpOptionsRequest), arg0) -} - -// CreateDhcpOptionsWithContext mocks base method. -func (m *MockEC2) CreateDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.CreateDhcpOptionsInput, arg2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateDhcpOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateDhcpOptionsWithContext indicates an expected call of CreateDhcpOptionsWithContext. -func (mr *MockEC2MockRecorder) CreateDhcpOptionsWithContext(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, "CreateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).CreateDhcpOptionsWithContext), varargs...) -} - -// CreateEgressOnlyInternetGateway mocks base method. -func (m *MockEC2) CreateEgressOnlyInternetGateway(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway. -func (mr *MockEC2MockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2)(nil).CreateEgressOnlyInternetGateway), arg0) -} - -// CreateEgressOnlyInternetGatewayRequest mocks base method. -func (m *MockEC2) CreateEgressOnlyInternetGatewayRequest(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateEgressOnlyInternetGatewayOutput) - return ret0, ret1 -} - -// CreateEgressOnlyInternetGatewayRequest indicates an expected call of CreateEgressOnlyInternetGatewayRequest. -func (mr *MockEC2MockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateEgressOnlyInternetGatewayRequest), arg0) -} - -// CreateEgressOnlyInternetGatewayWithContext mocks base method. -func (m *MockEC2) CreateEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateEgressOnlyInternetGatewayWithContext indicates an expected call of CreateEgressOnlyInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateEgressOnlyInternetGatewayWithContext(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, "CreateEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateEgressOnlyInternetGatewayWithContext), varargs...) -} - -// CreateFleet mocks base method. -func (m *MockEC2) CreateFleet(arg0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFleet", arg0) - ret0, _ := ret[0].(*ec2.CreateFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFleet indicates an expected call of CreateFleet. -func (mr *MockEC2MockRecorder) CreateFleet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2)(nil).CreateFleet), arg0) -} - -// CreateFleetRequest mocks base method. -func (m *MockEC2) CreateFleetRequest(arg0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFleetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateFleetOutput) - return ret0, ret1 -} - -// CreateFleetRequest indicates an expected call of CreateFleetRequest. -func (mr *MockEC2MockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2)(nil).CreateFleetRequest), arg0) -} - -// CreateFleetWithContext mocks base method. -func (m *MockEC2) CreateFleetWithContext(arg0 context.Context, arg1 *ec2.CreateFleetInput, arg2 ...request.Option) (*ec2.CreateFleetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFleetWithContext indicates an expected call of CreateFleetWithContext. -func (mr *MockEC2MockRecorder) CreateFleetWithContext(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, "CreateFleetWithContext", reflect.TypeOf((*MockEC2)(nil).CreateFleetWithContext), varargs...) -} - -// CreateFlowLogs mocks base method. -func (m *MockEC2) CreateFlowLogs(arg0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFlowLogs", arg0) - ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFlowLogs indicates an expected call of CreateFlowLogs. -func (mr *MockEC2MockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2)(nil).CreateFlowLogs), arg0) -} - -// CreateFlowLogsRequest mocks base method. -func (m *MockEC2) CreateFlowLogsRequest(arg0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFlowLogsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateFlowLogsOutput) - return ret0, ret1 -} - -// CreateFlowLogsRequest indicates an expected call of CreateFlowLogsRequest. -func (mr *MockEC2MockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2)(nil).CreateFlowLogsRequest), arg0) -} - -// CreateFlowLogsWithContext mocks base method. -func (m *MockEC2) CreateFlowLogsWithContext(arg0 context.Context, arg1 *ec2.CreateFlowLogsInput, arg2 ...request.Option) (*ec2.CreateFlowLogsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateFlowLogsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFlowLogsWithContext indicates an expected call of CreateFlowLogsWithContext. -func (mr *MockEC2MockRecorder) CreateFlowLogsWithContext(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, "CreateFlowLogsWithContext", reflect.TypeOf((*MockEC2)(nil).CreateFlowLogsWithContext), varargs...) -} - -// CreateFpgaImage mocks base method. -func (m *MockEC2) CreateFpgaImage(arg0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFpgaImage", arg0) - ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFpgaImage indicates an expected call of CreateFpgaImage. -func (mr *MockEC2MockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2)(nil).CreateFpgaImage), arg0) -} - -// CreateFpgaImageRequest mocks base method. -func (m *MockEC2) CreateFpgaImageRequest(arg0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateFpgaImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateFpgaImageOutput) - return ret0, ret1 -} - -// CreateFpgaImageRequest indicates an expected call of CreateFpgaImageRequest. -func (mr *MockEC2MockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2)(nil).CreateFpgaImageRequest), arg0) -} - -// CreateFpgaImageWithContext mocks base method. -func (m *MockEC2) CreateFpgaImageWithContext(arg0 context.Context, arg1 *ec2.CreateFpgaImageInput, arg2 ...request.Option) (*ec2.CreateFpgaImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateFpgaImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateFpgaImageWithContext indicates an expected call of CreateFpgaImageWithContext. -func (mr *MockEC2MockRecorder) CreateFpgaImageWithContext(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, "CreateFpgaImageWithContext", reflect.TypeOf((*MockEC2)(nil).CreateFpgaImageWithContext), varargs...) -} - -// CreateImage mocks base method. -func (m *MockEC2) CreateImage(arg0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateImage", arg0) - ret0, _ := ret[0].(*ec2.CreateImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateImage indicates an expected call of CreateImage. -func (mr *MockEC2MockRecorder) CreateImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2)(nil).CreateImage), arg0) -} - -// CreateImageRequest mocks base method. -func (m *MockEC2) CreateImageRequest(arg0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateImageOutput) - return ret0, ret1 -} - -// CreateImageRequest indicates an expected call of CreateImageRequest. -func (mr *MockEC2MockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2)(nil).CreateImageRequest), arg0) -} - -// CreateImageWithContext mocks base method. -func (m *MockEC2) CreateImageWithContext(arg0 context.Context, arg1 *ec2.CreateImageInput, arg2 ...request.Option) (*ec2.CreateImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateImageWithContext indicates an expected call of CreateImageWithContext. -func (mr *MockEC2MockRecorder) CreateImageWithContext(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, "CreateImageWithContext", reflect.TypeOf((*MockEC2)(nil).CreateImageWithContext), varargs...) -} - -// CreateInstanceConnectEndpoint mocks base method. -func (m *MockEC2) CreateInstanceConnectEndpoint(arg0 *ec2.CreateInstanceConnectEndpointInput) (*ec2.CreateInstanceConnectEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceConnectEndpoint", arg0) - ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceConnectEndpoint indicates an expected call of CreateInstanceConnectEndpoint. -func (mr *MockEC2MockRecorder) CreateInstanceConnectEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpoint", reflect.TypeOf((*MockEC2)(nil).CreateInstanceConnectEndpoint), arg0) -} - -// CreateInstanceConnectEndpointRequest mocks base method. -func (m *MockEC2) CreateInstanceConnectEndpointRequest(arg0 *ec2.CreateInstanceConnectEndpointInput) (*request.Request, *ec2.CreateInstanceConnectEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateInstanceConnectEndpointOutput) - return ret0, ret1 -} - -// CreateInstanceConnectEndpointRequest indicates an expected call of CreateInstanceConnectEndpointRequest. -func (mr *MockEC2MockRecorder) CreateInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2)(nil).CreateInstanceConnectEndpointRequest), arg0) -} - -// CreateInstanceConnectEndpointWithContext mocks base method. -func (m *MockEC2) CreateInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.CreateInstanceConnectEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateInstanceConnectEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateInstanceConnectEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceConnectEndpointWithContext indicates an expected call of CreateInstanceConnectEndpointWithContext. -func (mr *MockEC2MockRecorder) CreateInstanceConnectEndpointWithContext(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, "CreateInstanceConnectEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).CreateInstanceConnectEndpointWithContext), varargs...) -} - -// CreateInstanceEventWindow mocks base method. -func (m *MockEC2) CreateInstanceEventWindow(arg0 *ec2.CreateInstanceEventWindowInput) (*ec2.CreateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceEventWindow", arg0) - ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceEventWindow indicates an expected call of CreateInstanceEventWindow. -func (mr *MockEC2MockRecorder) CreateInstanceEventWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindow", reflect.TypeOf((*MockEC2)(nil).CreateInstanceEventWindow), arg0) -} - -// CreateInstanceEventWindowRequest mocks base method. -func (m *MockEC2) CreateInstanceEventWindowRequest(arg0 *ec2.CreateInstanceEventWindowInput) (*request.Request, *ec2.CreateInstanceEventWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceEventWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateInstanceEventWindowOutput) - return ret0, ret1 -} - -// CreateInstanceEventWindowRequest indicates an expected call of CreateInstanceEventWindowRequest. -func (mr *MockEC2MockRecorder) CreateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2)(nil).CreateInstanceEventWindowRequest), arg0) -} - -// CreateInstanceEventWindowWithContext mocks base method. -func (m *MockEC2) CreateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.CreateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateInstanceEventWindowWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceEventWindowWithContext indicates an expected call of CreateInstanceEventWindowWithContext. -func (mr *MockEC2MockRecorder) CreateInstanceEventWindowWithContext(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, "CreateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2)(nil).CreateInstanceEventWindowWithContext), varargs...) -} - -// CreateInstanceExportTask mocks base method. -func (m *MockEC2) CreateInstanceExportTask(arg0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceExportTask", arg0) - ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceExportTask indicates an expected call of CreateInstanceExportTask. -func (mr *MockEC2MockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2)(nil).CreateInstanceExportTask), arg0) -} - -// CreateInstanceExportTaskRequest mocks base method. -func (m *MockEC2) CreateInstanceExportTaskRequest(arg0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInstanceExportTaskRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateInstanceExportTaskOutput) - return ret0, ret1 -} - -// CreateInstanceExportTaskRequest indicates an expected call of CreateInstanceExportTaskRequest. -func (mr *MockEC2MockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2)(nil).CreateInstanceExportTaskRequest), arg0) -} - -// CreateInstanceExportTaskWithContext mocks base method. -func (m *MockEC2) CreateInstanceExportTaskWithContext(arg0 context.Context, arg1 *ec2.CreateInstanceExportTaskInput, arg2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateInstanceExportTaskWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInstanceExportTaskWithContext indicates an expected call of CreateInstanceExportTaskWithContext. -func (mr *MockEC2MockRecorder) CreateInstanceExportTaskWithContext(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, "CreateInstanceExportTaskWithContext", reflect.TypeOf((*MockEC2)(nil).CreateInstanceExportTaskWithContext), varargs...) -} - -// CreateInternetGateway mocks base method. -func (m *MockEC2) CreateInternetGateway(arg0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInternetGateway indicates an expected call of CreateInternetGateway. -func (mr *MockEC2MockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2)(nil).CreateInternetGateway), arg0) -} - -// CreateInternetGatewayRequest mocks base method. -func (m *MockEC2) CreateInternetGatewayRequest(arg0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateInternetGatewayOutput) - return ret0, ret1 -} - -// CreateInternetGatewayRequest indicates an expected call of CreateInternetGatewayRequest. -func (mr *MockEC2MockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateInternetGatewayRequest), arg0) -} - -// CreateInternetGatewayWithContext mocks base method. -func (m *MockEC2) CreateInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateInternetGatewayWithContext indicates an expected call of CreateInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateInternetGatewayWithContext(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, "CreateInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateInternetGatewayWithContext), varargs...) -} - -// CreateIpam mocks base method. -func (m *MockEC2) CreateIpam(arg0 *ec2.CreateIpamInput) (*ec2.CreateIpamOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpam", arg0) - ret0, _ := ret[0].(*ec2.CreateIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpam indicates an expected call of CreateIpam. -func (mr *MockEC2MockRecorder) CreateIpam(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpam", reflect.TypeOf((*MockEC2)(nil).CreateIpam), arg0) -} - -// CreateIpamPool mocks base method. -func (m *MockEC2) CreateIpamPool(arg0 *ec2.CreateIpamPoolInput) (*ec2.CreateIpamPoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamPool", arg0) - ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamPool indicates an expected call of CreateIpamPool. -func (mr *MockEC2MockRecorder) CreateIpamPool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPool", reflect.TypeOf((*MockEC2)(nil).CreateIpamPool), arg0) -} - -// CreateIpamPoolRequest mocks base method. -func (m *MockEC2) CreateIpamPoolRequest(arg0 *ec2.CreateIpamPoolInput) (*request.Request, *ec2.CreateIpamPoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamPoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateIpamPoolOutput) - return ret0, ret1 -} - -// CreateIpamPoolRequest indicates an expected call of CreateIpamPoolRequest. -func (mr *MockEC2MockRecorder) CreateIpamPoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamPoolRequest", reflect.TypeOf((*MockEC2)(nil).CreateIpamPoolRequest), arg0) -} - -// CreateIpamPoolWithContext mocks base method. -func (m *MockEC2) CreateIpamPoolWithContext(arg0 context.Context, arg1 *ec2.CreateIpamPoolInput, arg2 ...request.Option) (*ec2.CreateIpamPoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateIpamPoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamPoolWithContext indicates an expected call of CreateIpamPoolWithContext. -func (mr *MockEC2MockRecorder) CreateIpamPoolWithContext(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, "CreateIpamPoolWithContext", reflect.TypeOf((*MockEC2)(nil).CreateIpamPoolWithContext), varargs...) -} - -// CreateIpamRequest mocks base method. -func (m *MockEC2) CreateIpamRequest(arg0 *ec2.CreateIpamInput) (*request.Request, *ec2.CreateIpamOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateIpamOutput) - return ret0, ret1 -} - -// CreateIpamRequest indicates an expected call of CreateIpamRequest. -func (mr *MockEC2MockRecorder) CreateIpamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamRequest", reflect.TypeOf((*MockEC2)(nil).CreateIpamRequest), arg0) -} - -// CreateIpamResourceDiscovery mocks base method. -func (m *MockEC2) CreateIpamResourceDiscovery(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*ec2.CreateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamResourceDiscovery", arg0) - ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamResourceDiscovery indicates an expected call of CreateIpamResourceDiscovery. -func (mr *MockEC2MockRecorder) CreateIpamResourceDiscovery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscovery", reflect.TypeOf((*MockEC2)(nil).CreateIpamResourceDiscovery), arg0) -} - -// CreateIpamResourceDiscoveryRequest mocks base method. -func (m *MockEC2) CreateIpamResourceDiscoveryRequest(arg0 *ec2.CreateIpamResourceDiscoveryInput) (*request.Request, *ec2.CreateIpamResourceDiscoveryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateIpamResourceDiscoveryOutput) - return ret0, ret1 -} - -// CreateIpamResourceDiscoveryRequest indicates an expected call of CreateIpamResourceDiscoveryRequest. -func (mr *MockEC2MockRecorder) CreateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2)(nil).CreateIpamResourceDiscoveryRequest), arg0) -} - -// CreateIpamResourceDiscoveryWithContext mocks base method. -func (m *MockEC2) CreateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.CreateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.CreateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateIpamResourceDiscoveryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamResourceDiscoveryWithContext indicates an expected call of CreateIpamResourceDiscoveryWithContext. -func (mr *MockEC2MockRecorder) CreateIpamResourceDiscoveryWithContext(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, "CreateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2)(nil).CreateIpamResourceDiscoveryWithContext), varargs...) -} - -// CreateIpamScope mocks base method. -func (m *MockEC2) CreateIpamScope(arg0 *ec2.CreateIpamScopeInput) (*ec2.CreateIpamScopeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamScope", arg0) - ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamScope indicates an expected call of CreateIpamScope. -func (mr *MockEC2MockRecorder) CreateIpamScope(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScope", reflect.TypeOf((*MockEC2)(nil).CreateIpamScope), arg0) -} - -// CreateIpamScopeRequest mocks base method. -func (m *MockEC2) CreateIpamScopeRequest(arg0 *ec2.CreateIpamScopeInput) (*request.Request, *ec2.CreateIpamScopeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateIpamScopeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateIpamScopeOutput) - return ret0, ret1 -} - -// CreateIpamScopeRequest indicates an expected call of CreateIpamScopeRequest. -func (mr *MockEC2MockRecorder) CreateIpamScopeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIpamScopeRequest", reflect.TypeOf((*MockEC2)(nil).CreateIpamScopeRequest), arg0) -} - -// CreateIpamScopeWithContext mocks base method. -func (m *MockEC2) CreateIpamScopeWithContext(arg0 context.Context, arg1 *ec2.CreateIpamScopeInput, arg2 ...request.Option) (*ec2.CreateIpamScopeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateIpamScopeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamScopeWithContext indicates an expected call of CreateIpamScopeWithContext. -func (mr *MockEC2MockRecorder) CreateIpamScopeWithContext(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, "CreateIpamScopeWithContext", reflect.TypeOf((*MockEC2)(nil).CreateIpamScopeWithContext), varargs...) -} - -// CreateIpamWithContext mocks base method. -func (m *MockEC2) CreateIpamWithContext(arg0 context.Context, arg1 *ec2.CreateIpamInput, arg2 ...request.Option) (*ec2.CreateIpamOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateIpamWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateIpamWithContext indicates an expected call of CreateIpamWithContext. -func (mr *MockEC2MockRecorder) CreateIpamWithContext(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, "CreateIpamWithContext", reflect.TypeOf((*MockEC2)(nil).CreateIpamWithContext), varargs...) -} - -// CreateKeyPair mocks base method. -func (m *MockEC2) CreateKeyPair(arg0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateKeyPair", arg0) - ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateKeyPair indicates an expected call of CreateKeyPair. -func (mr *MockEC2MockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2)(nil).CreateKeyPair), arg0) -} - -// CreateKeyPairRequest mocks base method. -func (m *MockEC2) CreateKeyPairRequest(arg0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateKeyPairRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateKeyPairOutput) - return ret0, ret1 -} - -// CreateKeyPairRequest indicates an expected call of CreateKeyPairRequest. -func (mr *MockEC2MockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2)(nil).CreateKeyPairRequest), arg0) -} - -// CreateKeyPairWithContext mocks base method. -func (m *MockEC2) CreateKeyPairWithContext(arg0 context.Context, arg1 *ec2.CreateKeyPairInput, arg2 ...request.Option) (*ec2.CreateKeyPairOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateKeyPairWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateKeyPairWithContext indicates an expected call of CreateKeyPairWithContext. -func (mr *MockEC2MockRecorder) CreateKeyPairWithContext(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, "CreateKeyPairWithContext", reflect.TypeOf((*MockEC2)(nil).CreateKeyPairWithContext), varargs...) -} - -// CreateLaunchTemplate mocks base method. -func (m *MockEC2) CreateLaunchTemplate(arg0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0) - ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate. -func (mr *MockEC2MockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplate), arg0) -} - -// CreateLaunchTemplateRequest mocks base method. -func (m *MockEC2) CreateLaunchTemplateRequest(arg0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLaunchTemplateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLaunchTemplateOutput) - return ret0, ret1 -} - -// CreateLaunchTemplateRequest indicates an expected call of CreateLaunchTemplateRequest. -func (mr *MockEC2MockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplateRequest), arg0) -} - -// CreateLaunchTemplateVersion mocks base method. -func (m *MockEC2) CreateLaunchTemplateVersion(arg0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0) - ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion. -func (mr *MockEC2MockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplateVersion), arg0) -} - -// CreateLaunchTemplateVersionRequest mocks base method. -func (m *MockEC2) CreateLaunchTemplateVersionRequest(arg0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLaunchTemplateVersionOutput) - return ret0, ret1 -} - -// CreateLaunchTemplateVersionRequest indicates an expected call of CreateLaunchTemplateVersionRequest. -func (mr *MockEC2MockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplateVersionRequest), arg0) -} - -// CreateLaunchTemplateVersionWithContext mocks base method. -func (m *MockEC2) CreateLaunchTemplateVersionWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLaunchTemplateVersionWithContext indicates an expected call of CreateLaunchTemplateVersionWithContext. -func (mr *MockEC2MockRecorder) CreateLaunchTemplateVersionWithContext(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, "CreateLaunchTemplateVersionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplateVersionWithContext), varargs...) -} - -// CreateLaunchTemplateWithContext mocks base method. -func (m *MockEC2) CreateLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLaunchTemplateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLaunchTemplateWithContext indicates an expected call of CreateLaunchTemplateWithContext. -func (mr *MockEC2MockRecorder) CreateLaunchTemplateWithContext(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, "CreateLaunchTemplateWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLaunchTemplateWithContext), varargs...) -} - -// CreateLocalGatewayRoute mocks base method. -func (m *MockEC2) CreateLocalGatewayRoute(arg0 *ec2.CreateLocalGatewayRouteInput) (*ec2.CreateLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRoute indicates an expected call of CreateLocalGatewayRoute. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRoute", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRoute), arg0) -} - -// CreateLocalGatewayRouteRequest mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteRequest(arg0 *ec2.CreateLocalGatewayRouteInput) (*request.Request, *ec2.CreateLocalGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteOutput) - return ret0, ret1 -} - -// CreateLocalGatewayRouteRequest indicates an expected call of CreateLocalGatewayRouteRequest. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteRequest), arg0) -} - -// CreateLocalGatewayRouteTable mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTable(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*ec2.CreateLocalGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTable indicates an expected call of CreateLocalGatewayRouteTable. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTable), arg0) -} - -// CreateLocalGatewayRouteTableRequest mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableRequest(arg0 *ec2.CreateLocalGatewayRouteTableInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableOutput) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableRequest indicates an expected call of CreateLocalGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableRequest), arg0) -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0) -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0) -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext indicates an expected call of CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(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, "CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext), varargs...) -} - -// CreateLocalGatewayRouteTableVpcAssociation mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVpcAssociation(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociation", arg0) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVpcAssociation indicates an expected call of CreateLocalGatewayRouteTableVpcAssociation. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVpcAssociation), arg0) -} - -// CreateLocalGatewayRouteTableVpcAssociationRequest mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationRequest. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVpcAssociationRequest), arg0) -} - -// CreateLocalGatewayRouteTableVpcAssociationWithContext mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableVpcAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableVpcAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of CreateLocalGatewayRouteTableVpcAssociationWithContext. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableVpcAssociationWithContext(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, "CreateLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableVpcAssociationWithContext), varargs...) -} - -// CreateLocalGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteTableWithContext indicates an expected call of CreateLocalGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteTableWithContext(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, "CreateLocalGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteTableWithContext), varargs...) -} - -// CreateLocalGatewayRouteWithContext mocks base method. -func (m *MockEC2) CreateLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLocalGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLocalGatewayRouteWithContext indicates an expected call of CreateLocalGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) CreateLocalGatewayRouteWithContext(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, "CreateLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).CreateLocalGatewayRouteWithContext), varargs...) -} - -// CreateManagedPrefixList mocks base method. -func (m *MockEC2) CreateManagedPrefixList(arg0 *ec2.CreateManagedPrefixListInput) (*ec2.CreateManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateManagedPrefixList", arg0) - ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateManagedPrefixList indicates an expected call of CreateManagedPrefixList. -func (mr *MockEC2MockRecorder) CreateManagedPrefixList(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixList", reflect.TypeOf((*MockEC2)(nil).CreateManagedPrefixList), arg0) -} - -// CreateManagedPrefixListRequest mocks base method. -func (m *MockEC2) CreateManagedPrefixListRequest(arg0 *ec2.CreateManagedPrefixListInput) (*request.Request, *ec2.CreateManagedPrefixListOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateManagedPrefixListRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateManagedPrefixListOutput) - return ret0, ret1 -} - -// CreateManagedPrefixListRequest indicates an expected call of CreateManagedPrefixListRequest. -func (mr *MockEC2MockRecorder) CreateManagedPrefixListRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedPrefixListRequest", reflect.TypeOf((*MockEC2)(nil).CreateManagedPrefixListRequest), arg0) -} - -// CreateManagedPrefixListWithContext mocks base method. -func (m *MockEC2) CreateManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.CreateManagedPrefixListInput, arg2 ...request.Option) (*ec2.CreateManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateManagedPrefixListWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateManagedPrefixListWithContext indicates an expected call of CreateManagedPrefixListWithContext. -func (mr *MockEC2MockRecorder) CreateManagedPrefixListWithContext(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, "CreateManagedPrefixListWithContext", reflect.TypeOf((*MockEC2)(nil).CreateManagedPrefixListWithContext), varargs...) -} - -// CreateNatGateway mocks base method. -func (m *MockEC2) CreateNatGateway(arg0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNatGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNatGateway indicates an expected call of CreateNatGateway. -func (mr *MockEC2MockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2)(nil).CreateNatGateway), arg0) -} - -// CreateNatGatewayRequest mocks base method. -func (m *MockEC2) CreateNatGatewayRequest(arg0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNatGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNatGatewayOutput) - return ret0, ret1 -} - -// CreateNatGatewayRequest indicates an expected call of CreateNatGatewayRequest. -func (mr *MockEC2MockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateNatGatewayRequest), arg0) -} - -// CreateNatGatewayWithContext mocks base method. -func (m *MockEC2) CreateNatGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...request.Option) (*ec2.CreateNatGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNatGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNatGatewayWithContext indicates an expected call of CreateNatGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateNatGatewayWithContext(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, "CreateNatGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNatGatewayWithContext), varargs...) -} - -// CreateNetworkAcl mocks base method. -func (m *MockEC2) CreateNetworkAcl(arg0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkAcl", arg0) - ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkAcl indicates an expected call of CreateNetworkAcl. -func (mr *MockEC2MockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAcl), arg0) -} - -// CreateNetworkAclEntry mocks base method. -func (m *MockEC2) CreateNetworkAclEntry(arg0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkAclEntry", arg0) - ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkAclEntry indicates an expected call of CreateNetworkAclEntry. -func (mr *MockEC2MockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAclEntry), arg0) -} - -// CreateNetworkAclEntryRequest mocks base method. -func (m *MockEC2) CreateNetworkAclEntryRequest(arg0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkAclEntryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNetworkAclEntryOutput) - return ret0, ret1 -} - -// CreateNetworkAclEntryRequest indicates an expected call of CreateNetworkAclEntryRequest. -func (mr *MockEC2MockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAclEntryRequest), arg0) -} - -// CreateNetworkAclEntryWithContext mocks base method. -func (m *MockEC2) CreateNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclEntryInput, arg2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNetworkAclEntryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkAclEntryWithContext indicates an expected call of CreateNetworkAclEntryWithContext. -func (mr *MockEC2MockRecorder) CreateNetworkAclEntryWithContext(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, "CreateNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAclEntryWithContext), varargs...) -} - -// CreateNetworkAclRequest mocks base method. -func (m *MockEC2) CreateNetworkAclRequest(arg0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkAclRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNetworkAclOutput) - return ret0, ret1 -} - -// CreateNetworkAclRequest indicates an expected call of CreateNetworkAclRequest. -func (mr *MockEC2MockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAclRequest), arg0) -} - -// CreateNetworkAclWithContext mocks base method. -func (m *MockEC2) CreateNetworkAclWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkAclInput, arg2 ...request.Option) (*ec2.CreateNetworkAclOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNetworkAclWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkAclWithContext indicates an expected call of CreateNetworkAclWithContext. -func (mr *MockEC2MockRecorder) CreateNetworkAclWithContext(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, "CreateNetworkAclWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNetworkAclWithContext), varargs...) -} - -// CreateNetworkInsightsAccessScope mocks base method. -func (m *MockEC2) CreateNetworkInsightsAccessScope(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScope", arg0) - ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInsightsAccessScope indicates an expected call of CreateNetworkInsightsAccessScope. -func (mr *MockEC2MockRecorder) CreateNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInsightsAccessScope), arg0) -} - -// CreateNetworkInsightsAccessScopeRequest mocks base method. -func (m *MockEC2) CreateNetworkInsightsAccessScopeRequest(arg0 *ec2.CreateNetworkInsightsAccessScopeInput) (*request.Request, *ec2.CreateNetworkInsightsAccessScopeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNetworkInsightsAccessScopeOutput) - return ret0, ret1 -} - -// CreateNetworkInsightsAccessScopeRequest indicates an expected call of CreateNetworkInsightsAccessScopeRequest. -func (mr *MockEC2MockRecorder) CreateNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInsightsAccessScopeRequest), arg0) -} - -// CreateNetworkInsightsAccessScopeWithContext mocks base method. -func (m *MockEC2) CreateNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.CreateNetworkInsightsAccessScopeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNetworkInsightsAccessScopeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNetworkInsightsAccessScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInsightsAccessScopeWithContext indicates an expected call of CreateNetworkInsightsAccessScopeWithContext. -func (mr *MockEC2MockRecorder) CreateNetworkInsightsAccessScopeWithContext(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, "CreateNetworkInsightsAccessScopeWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInsightsAccessScopeWithContext), varargs...) -} - -// CreateNetworkInsightsPath mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateNetworkInsightsPath(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPath", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInsightsPath), arg0) -} - -// CreateNetworkInsightsPathRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInsightsPathRequest), arg0) -} - -// CreateNetworkInsightsPathWithContext mocks base method. -func (m *MockEC2) CreateNetworkInsightsPathWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateNetworkInsightsPathWithContext), varargs...) -} - -// CreateNetworkInterface mocks base method. -func (m *MockEC2) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0) - ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInterface indicates an expected call of CreateNetworkInterface. -func (mr *MockEC2MockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterface), arg0) -} - -// CreateNetworkInterfacePermission mocks base method. -func (m *MockEC2) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0) - ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission. -func (mr *MockEC2MockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterfacePermission), arg0) -} - -// CreateNetworkInterfacePermissionRequest mocks base method. -func (m *MockEC2) CreateNetworkInterfacePermissionRequest(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNetworkInterfacePermissionOutput) - return ret0, ret1 -} - -// CreateNetworkInterfacePermissionRequest indicates an expected call of CreateNetworkInterfacePermissionRequest. -func (mr *MockEC2MockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterfacePermissionRequest), arg0) -} - -// CreateNetworkInterfacePermissionWithContext mocks base method. -func (m *MockEC2) CreateNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInterfacePermissionWithContext indicates an expected call of CreateNetworkInterfacePermissionWithContext. -func (mr *MockEC2MockRecorder) CreateNetworkInterfacePermissionWithContext(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, "CreateNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterfacePermissionWithContext), varargs...) -} - -// CreateNetworkInterfaceRequest mocks base method. -func (m *MockEC2) CreateNetworkInterfaceRequest(arg0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateNetworkInterfaceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateNetworkInterfaceOutput) - return ret0, ret1 -} - -// CreateNetworkInterfaceRequest indicates an expected call of CreateNetworkInterfaceRequest. -func (mr *MockEC2MockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterfaceRequest), arg0) -} - -// CreateNetworkInterfaceWithContext mocks base method. -func (m *MockEC2) CreateNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.CreateNetworkInterfaceInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateNetworkInterfaceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateNetworkInterfaceWithContext indicates an expected call of CreateNetworkInterfaceWithContext. -func (mr *MockEC2MockRecorder) CreateNetworkInterfaceWithContext(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, "CreateNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2)(nil).CreateNetworkInterfaceWithContext), varargs...) -} - -// CreatePlacementGroup mocks base method. -func (m *MockEC2) CreatePlacementGroup(arg0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePlacementGroup", arg0) - ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePlacementGroup indicates an expected call of CreatePlacementGroup. -func (mr *MockEC2MockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2)(nil).CreatePlacementGroup), arg0) -} - -// CreatePlacementGroupRequest mocks base method. -func (m *MockEC2) CreatePlacementGroupRequest(arg0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePlacementGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreatePlacementGroupOutput) - return ret0, ret1 -} - -// CreatePlacementGroupRequest indicates an expected call of CreatePlacementGroupRequest. -func (mr *MockEC2MockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2)(nil).CreatePlacementGroupRequest), arg0) -} - -// CreatePlacementGroupWithContext mocks base method. -func (m *MockEC2) CreatePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.CreatePlacementGroupInput, arg2 ...request.Option) (*ec2.CreatePlacementGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreatePlacementGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePlacementGroupWithContext indicates an expected call of CreatePlacementGroupWithContext. -func (mr *MockEC2MockRecorder) CreatePlacementGroupWithContext(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, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2)(nil).CreatePlacementGroupWithContext), varargs...) -} - -// CreatePublicIpv4Pool mocks base method. -func (m *MockEC2) CreatePublicIpv4Pool(arg0 *ec2.CreatePublicIpv4PoolInput) (*ec2.CreatePublicIpv4PoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePublicIpv4Pool", arg0) - ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePublicIpv4Pool indicates an expected call of CreatePublicIpv4Pool. -func (mr *MockEC2MockRecorder) CreatePublicIpv4Pool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4Pool", reflect.TypeOf((*MockEC2)(nil).CreatePublicIpv4Pool), arg0) -} - -// CreatePublicIpv4PoolRequest mocks base method. -func (m *MockEC2) CreatePublicIpv4PoolRequest(arg0 *ec2.CreatePublicIpv4PoolInput) (*request.Request, *ec2.CreatePublicIpv4PoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePublicIpv4PoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreatePublicIpv4PoolOutput) - return ret0, ret1 -} - -// CreatePublicIpv4PoolRequest indicates an expected call of CreatePublicIpv4PoolRequest. -func (mr *MockEC2MockRecorder) CreatePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2)(nil).CreatePublicIpv4PoolRequest), arg0) -} - -// CreatePublicIpv4PoolWithContext mocks base method. -func (m *MockEC2) CreatePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.CreatePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.CreatePublicIpv4PoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreatePublicIpv4PoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreatePublicIpv4PoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreatePublicIpv4PoolWithContext indicates an expected call of CreatePublicIpv4PoolWithContext. -func (mr *MockEC2MockRecorder) CreatePublicIpv4PoolWithContext(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, "CreatePublicIpv4PoolWithContext", reflect.TypeOf((*MockEC2)(nil).CreatePublicIpv4PoolWithContext), varargs...) -} - -// CreateReplaceRootVolumeTask mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateReplaceRootVolumeTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTask", reflect.TypeOf((*MockEC2)(nil).CreateReplaceRootVolumeTask), arg0) -} - -// CreateReplaceRootVolumeTaskRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateReplaceRootVolumeTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReplaceRootVolumeTaskRequest", reflect.TypeOf((*MockEC2)(nil).CreateReplaceRootVolumeTaskRequest), arg0) -} - -// CreateReplaceRootVolumeTaskWithContext mocks base method. -func (m *MockEC2) CreateReplaceRootVolumeTaskWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateReplaceRootVolumeTaskWithContext), varargs...) -} - -// CreateReservedInstancesListing mocks base method. -func (m *MockEC2) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateReservedInstancesListing", arg0) - ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateReservedInstancesListing indicates an expected call of CreateReservedInstancesListing. -func (mr *MockEC2MockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2)(nil).CreateReservedInstancesListing), arg0) -} - -// CreateReservedInstancesListingRequest mocks base method. -func (m *MockEC2) CreateReservedInstancesListingRequest(arg0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateReservedInstancesListingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateReservedInstancesListingOutput) - return ret0, ret1 -} - -// CreateReservedInstancesListingRequest indicates an expected call of CreateReservedInstancesListingRequest. -func (mr *MockEC2MockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2)(nil).CreateReservedInstancesListingRequest), arg0) -} - -// CreateReservedInstancesListingWithContext mocks base method. -func (m *MockEC2) CreateReservedInstancesListingWithContext(arg0 context.Context, arg1 *ec2.CreateReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateReservedInstancesListingWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateReservedInstancesListingWithContext indicates an expected call of CreateReservedInstancesListingWithContext. -func (mr *MockEC2MockRecorder) CreateReservedInstancesListingWithContext(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, "CreateReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2)(nil).CreateReservedInstancesListingWithContext), varargs...) -} - -// CreateRestoreImageTask mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateRestoreImageTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTask", reflect.TypeOf((*MockEC2)(nil).CreateRestoreImageTask), arg0) -} - -// CreateRestoreImageTaskRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateRestoreImageTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRestoreImageTaskRequest", reflect.TypeOf((*MockEC2)(nil).CreateRestoreImageTaskRequest), arg0) -} - -// CreateRestoreImageTaskWithContext mocks base method. -func (m *MockEC2) CreateRestoreImageTaskWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateRestoreImageTaskWithContext), varargs...) -} - -// CreateRoute mocks base method. -func (m *MockEC2) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRoute", arg0) - ret0, _ := ret[0].(*ec2.CreateRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateRoute indicates an expected call of CreateRoute. -func (mr *MockEC2MockRecorder) CreateRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2)(nil).CreateRoute), arg0) -} - -// CreateRouteRequest mocks base method. -func (m *MockEC2) CreateRouteRequest(arg0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateRouteOutput) - return ret0, ret1 -} - -// CreateRouteRequest indicates an expected call of CreateRouteRequest. -func (mr *MockEC2MockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2)(nil).CreateRouteRequest), arg0) -} - -// CreateRouteTable mocks base method. -func (m *MockEC2) CreateRouteTable(arg0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRouteTable", arg0) - ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateRouteTable indicates an expected call of CreateRouteTable. -func (mr *MockEC2MockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2)(nil).CreateRouteTable), arg0) -} - -// CreateRouteTableRequest mocks base method. -func (m *MockEC2) CreateRouteTableRequest(arg0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateRouteTableOutput) - return ret0, ret1 -} - -// CreateRouteTableRequest indicates an expected call of CreateRouteTableRequest. -func (mr *MockEC2MockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).CreateRouteTableRequest), arg0) -} - -// CreateRouteTableWithContext mocks base method. -func (m *MockEC2) CreateRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...request.Option) (*ec2.CreateRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateRouteTableWithContext indicates an expected call of CreateRouteTableWithContext. -func (mr *MockEC2MockRecorder) CreateRouteTableWithContext(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, "CreateRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).CreateRouteTableWithContext), varargs...) -} - -// CreateRouteWithContext mocks base method. -func (m *MockEC2) CreateRouteWithContext(arg0 context.Context, arg1 *ec2.CreateRouteInput, arg2 ...request.Option) (*ec2.CreateRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateRouteWithContext indicates an expected call of CreateRouteWithContext. -func (mr *MockEC2MockRecorder) CreateRouteWithContext(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, "CreateRouteWithContext", reflect.TypeOf((*MockEC2)(nil).CreateRouteWithContext), varargs...) -} - -// CreateSecurityGroup mocks base method. -func (m *MockEC2) CreateSecurityGroup(arg0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0) - ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSecurityGroup indicates an expected call of CreateSecurityGroup. -func (mr *MockEC2MockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2)(nil).CreateSecurityGroup), arg0) -} - -// CreateSecurityGroupRequest mocks base method. -func (m *MockEC2) CreateSecurityGroupRequest(arg0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSecurityGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateSecurityGroupOutput) - return ret0, ret1 -} - -// CreateSecurityGroupRequest indicates an expected call of CreateSecurityGroupRequest. -func (mr *MockEC2MockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2)(nil).CreateSecurityGroupRequest), arg0) -} - -// CreateSecurityGroupWithContext mocks base method. -func (m *MockEC2) CreateSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...request.Option) (*ec2.CreateSecurityGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSecurityGroupWithContext indicates an expected call of CreateSecurityGroupWithContext. -func (mr *MockEC2MockRecorder) CreateSecurityGroupWithContext(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, "CreateSecurityGroupWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSecurityGroupWithContext), varargs...) -} - -// CreateSnapshot mocks base method. -func (m *MockEC2) CreateSnapshot(arg0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshot", arg0) - ret0, _ := ret[0].(*ec2.Snapshot) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSnapshot indicates an expected call of CreateSnapshot. -func (mr *MockEC2MockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2)(nil).CreateSnapshot), arg0) -} - -// CreateSnapshotRequest mocks base method. -func (m *MockEC2) CreateSnapshotRequest(arg0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.Snapshot) - return ret0, ret1 -} - -// CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest. -func (mr *MockEC2MockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2)(nil).CreateSnapshotRequest), arg0) -} - -// CreateSnapshotWithContext mocks base method. -func (m *MockEC2) CreateSnapshotWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.Snapshot) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext. -func (mr *MockEC2MockRecorder) CreateSnapshotWithContext(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, "CreateSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSnapshotWithContext), varargs...) -} - -// CreateSnapshots mocks base method. -func (m *MockEC2) CreateSnapshots(arg0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshots", arg0) - ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSnapshots indicates an expected call of CreateSnapshots. -func (mr *MockEC2MockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2)(nil).CreateSnapshots), arg0) -} - -// CreateSnapshotsRequest mocks base method. -func (m *MockEC2) CreateSnapshotsRequest(arg0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSnapshotsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateSnapshotsOutput) - return ret0, ret1 -} - -// CreateSnapshotsRequest indicates an expected call of CreateSnapshotsRequest. -func (mr *MockEC2MockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2)(nil).CreateSnapshotsRequest), arg0) -} - -// CreateSnapshotsWithContext mocks base method. -func (m *MockEC2) CreateSnapshotsWithContext(arg0 context.Context, arg1 *ec2.CreateSnapshotsInput, arg2 ...request.Option) (*ec2.CreateSnapshotsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSnapshotsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSnapshotsWithContext indicates an expected call of CreateSnapshotsWithContext. -func (mr *MockEC2MockRecorder) CreateSnapshotsWithContext(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, "CreateSnapshotsWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSnapshotsWithContext), varargs...) -} - -// CreateSpotDatafeedSubscription mocks base method. -func (m *MockEC2) CreateSpotDatafeedSubscription(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscription", arg0) - ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSpotDatafeedSubscription indicates an expected call of CreateSpotDatafeedSubscription. -func (mr *MockEC2MockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2)(nil).CreateSpotDatafeedSubscription), arg0) -} - -// CreateSpotDatafeedSubscriptionRequest mocks base method. -func (m *MockEC2) CreateSpotDatafeedSubscriptionRequest(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateSpotDatafeedSubscriptionOutput) - return ret0, ret1 -} - -// CreateSpotDatafeedSubscriptionRequest indicates an expected call of CreateSpotDatafeedSubscriptionRequest. -func (mr *MockEC2MockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2)(nil).CreateSpotDatafeedSubscriptionRequest), arg0) -} - -// CreateSpotDatafeedSubscriptionWithContext mocks base method. -func (m *MockEC2) CreateSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.CreateSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSpotDatafeedSubscriptionWithContext indicates an expected call of CreateSpotDatafeedSubscriptionWithContext. -func (mr *MockEC2MockRecorder) CreateSpotDatafeedSubscriptionWithContext(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, "CreateSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...) -} - -// CreateStoreImageTask mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateStoreImageTask(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTask", reflect.TypeOf((*MockEC2)(nil).CreateStoreImageTask), arg0) -} - -// CreateStoreImageTaskRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateStoreImageTaskRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateStoreImageTaskRequest", reflect.TypeOf((*MockEC2)(nil).CreateStoreImageTaskRequest), arg0) -} - -// CreateStoreImageTaskWithContext mocks base method. -func (m *MockEC2) CreateStoreImageTaskWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateStoreImageTaskWithContext), varargs...) -} - -// CreateSubnet mocks base method. -func (m *MockEC2) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubnet", arg0) - ret0, _ := ret[0].(*ec2.CreateSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubnet indicates an expected call of CreateSubnet. -func (mr *MockEC2MockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2)(nil).CreateSubnet), arg0) -} - -// CreateSubnetCidrReservation mocks base method. -func (m *MockEC2) CreateSubnetCidrReservation(arg0 *ec2.CreateSubnetCidrReservationInput) (*ec2.CreateSubnetCidrReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubnetCidrReservation", arg0) - ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubnetCidrReservation indicates an expected call of CreateSubnetCidrReservation. -func (mr *MockEC2MockRecorder) CreateSubnetCidrReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservation", reflect.TypeOf((*MockEC2)(nil).CreateSubnetCidrReservation), arg0) -} - -// CreateSubnetCidrReservationRequest mocks base method. -func (m *MockEC2) CreateSubnetCidrReservationRequest(arg0 *ec2.CreateSubnetCidrReservationInput) (*request.Request, *ec2.CreateSubnetCidrReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubnetCidrReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateSubnetCidrReservationOutput) - return ret0, ret1 -} - -// CreateSubnetCidrReservationRequest indicates an expected call of CreateSubnetCidrReservationRequest. -func (mr *MockEC2MockRecorder) CreateSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2)(nil).CreateSubnetCidrReservationRequest), arg0) -} - -// CreateSubnetCidrReservationWithContext mocks base method. -func (m *MockEC2) CreateSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.CreateSubnetCidrReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSubnetCidrReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateSubnetCidrReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubnetCidrReservationWithContext indicates an expected call of CreateSubnetCidrReservationWithContext. -func (mr *MockEC2MockRecorder) CreateSubnetCidrReservationWithContext(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, "CreateSubnetCidrReservationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSubnetCidrReservationWithContext), varargs...) -} - -// CreateSubnetRequest mocks base method. -func (m *MockEC2) CreateSubnetRequest(arg0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubnetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateSubnetOutput) - return ret0, ret1 -} - -// CreateSubnetRequest indicates an expected call of CreateSubnetRequest. -func (mr *MockEC2MockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2)(nil).CreateSubnetRequest), arg0) -} - -// CreateSubnetWithContext mocks base method. -func (m *MockEC2) CreateSubnetWithContext(arg0 context.Context, arg1 *ec2.CreateSubnetInput, arg2 ...request.Option) (*ec2.CreateSubnetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSubnetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubnetWithContext indicates an expected call of CreateSubnetWithContext. -func (mr *MockEC2MockRecorder) CreateSubnetWithContext(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, "CreateSubnetWithContext", reflect.TypeOf((*MockEC2)(nil).CreateSubnetWithContext), varargs...) -} - -// CreateTags mocks base method. -func (m *MockEC2) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTags", arg0) - ret0, _ := ret[0].(*ec2.CreateTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTags indicates an expected call of CreateTags. -func (mr *MockEC2MockRecorder) CreateTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2)(nil).CreateTags), arg0) -} - -// CreateTagsRequest mocks base method. -func (m *MockEC2) CreateTagsRequest(arg0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTagsOutput) - return ret0, ret1 -} - -// CreateTagsRequest indicates an expected call of CreateTagsRequest. -func (mr *MockEC2MockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2)(nil).CreateTagsRequest), arg0) -} - -// CreateTagsWithContext mocks base method. -func (m *MockEC2) CreateTagsWithContext(arg0 context.Context, arg1 *ec2.CreateTagsInput, arg2 ...request.Option) (*ec2.CreateTagsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTagsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTagsWithContext indicates an expected call of CreateTagsWithContext. -func (mr *MockEC2MockRecorder) CreateTagsWithContext(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, "CreateTagsWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTagsWithContext), varargs...) -} - -// CreateTrafficMirrorFilter mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilter), arg0) -} - -// CreateTrafficMirrorFilterRequest mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput) - return ret0, ret1 -} - -// CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilterRequest), arg0) -} - -// CreateTrafficMirrorFilterRule mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilterRule), arg0) -} - -// CreateTrafficMirrorFilterRuleRequest mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput) - return ret0, ret1 -} - -// CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilterRuleRequest), arg0) -} - -// CreateTrafficMirrorFilterRuleWithContext mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorFilterRuleWithContext indicates an expected call of CreateTrafficMirrorFilterRuleWithContext. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilterRuleWithContext(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, "CreateTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...) -} - -// CreateTrafficMirrorFilterWithContext mocks base method. -func (m *MockEC2) CreateTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorFilterWithContext indicates an expected call of CreateTrafficMirrorFilterWithContext. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorFilterWithContext(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, "CreateTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorFilterWithContext), varargs...) -} - -// CreateTrafficMirrorSession mocks base method. -func (m *MockEC2) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorSession), arg0) -} - -// CreateTrafficMirrorSessionRequest mocks base method. -func (m *MockEC2) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput) - return ret0, ret1 -} - -// CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorSessionRequest), arg0) -} - -// CreateTrafficMirrorSessionWithContext mocks base method. -func (m *MockEC2) CreateTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorSessionWithContext indicates an expected call of CreateTrafficMirrorSessionWithContext. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorSessionWithContext(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, "CreateTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorSessionWithContext), varargs...) -} - -// CreateTrafficMirrorTarget mocks base method. -func (m *MockEC2) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorTarget), arg0) -} - -// CreateTrafficMirrorTargetRequest mocks base method. -func (m *MockEC2) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTrafficMirrorTargetOutput) - return ret0, ret1 -} - -// CreateTrafficMirrorTargetRequest indicates an expected call of CreateTrafficMirrorTargetRequest. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorTargetRequest), arg0) -} - -// CreateTrafficMirrorTargetWithContext mocks base method. -func (m *MockEC2) CreateTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTrafficMirrorTargetWithContext indicates an expected call of CreateTrafficMirrorTargetWithContext. -func (mr *MockEC2MockRecorder) CreateTrafficMirrorTargetWithContext(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, "CreateTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTrafficMirrorTargetWithContext), varargs...) -} - -// CreateTransitGateway mocks base method. -func (m *MockEC2) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGateway indicates an expected call of CreateTransitGateway. -func (mr *MockEC2MockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2)(nil).CreateTransitGateway), arg0) -} - -// CreateTransitGatewayConnect mocks base method. -func (m *MockEC2) CreateTransitGatewayConnect(arg0 *ec2.CreateTransitGatewayConnectInput) (*ec2.CreateTransitGatewayConnectOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayConnect", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayConnect indicates an expected call of CreateTransitGatewayConnect. -func (mr *MockEC2MockRecorder) CreateTransitGatewayConnect(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnect", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayConnect), arg0) -} - -// CreateTransitGatewayConnectPeer mocks base method. -func (m *MockEC2) CreateTransitGatewayConnectPeer(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*ec2.CreateTransitGatewayConnectPeerOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeer", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectPeerOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayConnectPeer indicates an expected call of CreateTransitGatewayConnectPeer. -func (mr *MockEC2MockRecorder) CreateTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayConnectPeer), arg0) -} - -// CreateTransitGatewayConnectPeerRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayConnectPeerRequest(arg0 *ec2.CreateTransitGatewayConnectPeerInput) (*request.Request, *ec2.CreateTransitGatewayConnectPeerOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayConnectPeerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectPeerOutput) - return ret0, ret1 -} - -// CreateTransitGatewayConnectPeerRequest indicates an expected call of CreateTransitGatewayConnectPeerRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayConnectPeerRequest), arg0) -} - -// CreateTransitGatewayConnectPeerWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayConnectPeerWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayConnectPeerInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayConnectPeerOutput, error) { - m.ctrl.T.Helper() - 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 -} - -// CreateTransitGatewayConnectPeerWithContext indicates an expected call of CreateTransitGatewayConnectPeerWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayConnectPeerWithContext(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, "CreateTransitGatewayConnectPeerWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayConnectPeerWithContext), varargs...) -} - -// CreateTransitGatewayConnectRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayConnectRequest(arg0 *ec2.CreateTransitGatewayConnectInput) (*request.Request, *ec2.CreateTransitGatewayConnectOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayConnectRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayConnectOutput) - return ret0, ret1 -} - -// CreateTransitGatewayConnectRequest indicates an expected call of CreateTransitGatewayConnectRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayConnectRequest), arg0) -} - -// CreateTransitGatewayConnectWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayConnectWithContext(arg0 context.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, "CreateTransitGatewayConnectWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayConnectOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayConnectWithContext indicates an expected call of CreateTransitGatewayConnectWithContext. -func (mr *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateTransitGatewayConnectWithContext), varargs...) -} - -// CreateTransitGatewayMulticastDomain mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayMulticastDomain), arg0) -} - -// CreateTransitGatewayMulticastDomainRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayMulticastDomainRequest), arg0) -} - -// CreateTransitGatewayMulticastDomainWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayMulticastDomainWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...) -} - -// CreateTransitGatewayPeeringAttachment mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPeeringAttachment), arg0) -} - -// CreateTransitGatewayPeeringAttachmentRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0) -} - -// CreateTransitGatewayPeeringAttachmentWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayPeeringAttachmentWithContext(arg0 context.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 -} - -// CreateTransitGatewayPeeringAttachmentWithContext indicates an expected call of CreateTransitGatewayPeeringAttachmentWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPeeringAttachmentWithContext(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, "CreateTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPeeringAttachmentWithContext), varargs...) -} - -// CreateTransitGatewayPolicyTable mocks base method. -func (m *MockEC2) CreateTransitGatewayPolicyTable(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*ec2.CreateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTable", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayPolicyTable indicates an expected call of CreateTransitGatewayPolicyTable. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPolicyTable), arg0) -} - -// CreateTransitGatewayPolicyTableRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayPolicyTableRequest(arg0 *ec2.CreateTransitGatewayPolicyTableInput) (*request.Request, *ec2.CreateTransitGatewayPolicyTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayPolicyTableOutput) - return ret0, ret1 -} - -// CreateTransitGatewayPolicyTableRequest indicates an expected call of CreateTransitGatewayPolicyTableRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPolicyTableRequest), arg0) -} - -// CreateTransitGatewayPolicyTableWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayPolicyTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayPolicyTableWithContext indicates an expected call of CreateTransitGatewayPolicyTableWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPolicyTableWithContext(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, "CreateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPolicyTableWithContext), varargs...) -} - -// CreateTransitGatewayPrefixListReference mocks base method. -func (m *MockEC2) CreateTransitGatewayPrefixListReference(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReference", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayPrefixListReference indicates an expected call of CreateTransitGatewayPrefixListReference. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPrefixListReference), arg0) -} - -// CreateTransitGatewayPrefixListReferenceRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayPrefixListReferenceRequest(arg0 *ec2.CreateTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.CreateTransitGatewayPrefixListReferenceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) - return ret0, ret1 -} - -// CreateTransitGatewayPrefixListReferenceRequest indicates an expected call of CreateTransitGatewayPrefixListReferenceRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPrefixListReferenceRequest), arg0) -} - -// CreateTransitGatewayPrefixListReferenceWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayPrefixListReferenceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayPrefixListReferenceWithContext indicates an expected call of CreateTransitGatewayPrefixListReferenceWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayPrefixListReferenceWithContext(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, "CreateTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayPrefixListReferenceWithContext), varargs...) -} - -// CreateTransitGatewayRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput) - return ret0, ret1 -} - -// CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRequest), arg0) -} - -// CreateTransitGatewayRoute mocks base method. -func (m *MockEC2) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRoute), arg0) -} - -// CreateTransitGatewayRouteRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput) - return ret0, ret1 -} - -// CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteRequest), arg0) -} - -// CreateTransitGatewayRouteTable mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTable), arg0) -} - -// CreateTransitGatewayRouteTableAnnouncement mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTableAnnouncement(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncement", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTableAnnouncement indicates an expected call of CreateTransitGatewayRouteTableAnnouncement. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTableAnnouncement), arg0) -} - -// CreateTransitGatewayRouteTableAnnouncementRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.CreateTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableAnnouncementOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTableAnnouncementRequest indicates an expected call of CreateTransitGatewayRouteTableAnnouncementRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTableAnnouncementRequest), arg0) -} - -// CreateTransitGatewayRouteTableAnnouncementWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableAnnouncementOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableAnnouncementWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableAnnouncementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTableAnnouncementWithContext indicates an expected call of CreateTransitGatewayRouteTableAnnouncementWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTableAnnouncementWithContext(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, "CreateTransitGatewayRouteTableAnnouncementWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTableAnnouncementWithContext), varargs...) -} - -// CreateTransitGatewayRouteTableRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTableRequest), arg0) -} - -// CreateTransitGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRouteTableWithContext indicates an expected call of CreateTransitGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteTableWithContext(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, "CreateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteTableWithContext), varargs...) -} - -// CreateTransitGatewayRouteWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayRouteWithContext indicates an expected call of CreateTransitGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayRouteWithContext(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, "CreateTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayRouteWithContext), varargs...) -} - -// CreateTransitGatewayVpcAttachment mocks base method. -func (m *MockEC2) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment. -func (mr *MockEC2MockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayVpcAttachment), arg0) -} - -// CreateTransitGatewayVpcAttachmentRequest mocks base method. -func (m *MockEC2) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput) - return ret0, ret1 -} - -// CreateTransitGatewayVpcAttachmentRequest indicates an expected call of CreateTransitGatewayVpcAttachmentRequest. -func (mr *MockEC2MockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0) -} - -// CreateTransitGatewayVpcAttachmentWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayVpcAttachmentWithContext indicates an expected call of CreateTransitGatewayVpcAttachmentWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayVpcAttachmentWithContext(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, "CreateTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...) -} - -// CreateTransitGatewayWithContext mocks base method. -func (m *MockEC2) CreateTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTransitGatewayWithContext indicates an expected call of CreateTransitGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateTransitGatewayWithContext(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, "CreateTransitGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateTransitGatewayWithContext), varargs...) -} - -// CreateVerifiedAccessEndpoint mocks base method. -func (m *MockEC2) CreateVerifiedAccessEndpoint(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*ec2.CreateVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpoint", arg0) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessEndpoint indicates an expected call of CreateVerifiedAccessEndpoint. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessEndpoint), arg0) -} - -// CreateVerifiedAccessEndpointRequest mocks base method. -func (m *MockEC2) CreateVerifiedAccessEndpointRequest(arg0 *ec2.CreateVerifiedAccessEndpointInput) (*request.Request, *ec2.CreateVerifiedAccessEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVerifiedAccessEndpointOutput) - return ret0, ret1 -} - -// CreateVerifiedAccessEndpointRequest indicates an expected call of CreateVerifiedAccessEndpointRequest. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessEndpointRequest), arg0) -} - -// CreateVerifiedAccessEndpointWithContext mocks base method. -func (m *MockEC2) CreateVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVerifiedAccessEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessEndpointWithContext indicates an expected call of CreateVerifiedAccessEndpointWithContext. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessEndpointWithContext(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, "CreateVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessEndpointWithContext), varargs...) -} - -// CreateVerifiedAccessGroup mocks base method. -func (m *MockEC2) CreateVerifiedAccessGroup(arg0 *ec2.CreateVerifiedAccessGroupInput) (*ec2.CreateVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessGroup", arg0) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessGroup indicates an expected call of CreateVerifiedAccessGroup. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroup", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessGroup), arg0) -} - -// CreateVerifiedAccessGroupRequest mocks base method. -func (m *MockEC2) CreateVerifiedAccessGroupRequest(arg0 *ec2.CreateVerifiedAccessGroupInput) (*request.Request, *ec2.CreateVerifiedAccessGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVerifiedAccessGroupOutput) - return ret0, ret1 -} - -// CreateVerifiedAccessGroupRequest indicates an expected call of CreateVerifiedAccessGroupRequest. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessGroupRequest), arg0) -} - -// CreateVerifiedAccessGroupWithContext mocks base method. -func (m *MockEC2) CreateVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVerifiedAccessGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessGroupWithContext indicates an expected call of CreateVerifiedAccessGroupWithContext. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessGroupWithContext(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, "CreateVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessGroupWithContext), varargs...) -} - -// CreateVerifiedAccessInstance mocks base method. -func (m *MockEC2) CreateVerifiedAccessInstance(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*ec2.CreateVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessInstance", arg0) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessInstance indicates an expected call of CreateVerifiedAccessInstance. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstance", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessInstance), arg0) -} - -// CreateVerifiedAccessInstanceRequest mocks base method. -func (m *MockEC2) CreateVerifiedAccessInstanceRequest(arg0 *ec2.CreateVerifiedAccessInstanceInput) (*request.Request, *ec2.CreateVerifiedAccessInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVerifiedAccessInstanceOutput) - return ret0, ret1 -} - -// CreateVerifiedAccessInstanceRequest indicates an expected call of CreateVerifiedAccessInstanceRequest. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessInstanceRequest), arg0) -} - -// CreateVerifiedAccessInstanceWithContext mocks base method. -func (m *MockEC2) CreateVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVerifiedAccessInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessInstanceWithContext indicates an expected call of CreateVerifiedAccessInstanceWithContext. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessInstanceWithContext(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, "CreateVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessInstanceWithContext), varargs...) -} - -// CreateVerifiedAccessTrustProvider mocks base method. -func (m *MockEC2) CreateVerifiedAccessTrustProvider(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProvider", arg0) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessTrustProvider indicates an expected call of CreateVerifiedAccessTrustProvider. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessTrustProvider), arg0) -} - -// CreateVerifiedAccessTrustProviderRequest mocks base method. -func (m *MockEC2) CreateVerifiedAccessTrustProviderRequest(arg0 *ec2.CreateVerifiedAccessTrustProviderInput) (*request.Request, *ec2.CreateVerifiedAccessTrustProviderOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVerifiedAccessTrustProviderOutput) - return ret0, ret1 -} - -// CreateVerifiedAccessTrustProviderRequest indicates an expected call of CreateVerifiedAccessTrustProviderRequest. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessTrustProviderRequest), arg0) -} - -// CreateVerifiedAccessTrustProviderWithContext mocks base method. -func (m *MockEC2) CreateVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.CreateVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.CreateVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVerifiedAccessTrustProviderWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVerifiedAccessTrustProviderWithContext indicates an expected call of CreateVerifiedAccessTrustProviderWithContext. -func (mr *MockEC2MockRecorder) CreateVerifiedAccessTrustProviderWithContext(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, "CreateVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVerifiedAccessTrustProviderWithContext), varargs...) -} - -// CreateVolume mocks base method. -func (m *MockEC2) CreateVolume(arg0 *ec2.CreateVolumeInput) (*ec2.Volume, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVolume", arg0) - ret0, _ := ret[0].(*ec2.Volume) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVolume indicates an expected call of CreateVolume. -func (mr *MockEC2MockRecorder) CreateVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2)(nil).CreateVolume), arg0) -} - -// CreateVolumeRequest mocks base method. -func (m *MockEC2) CreateVolumeRequest(arg0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.Volume) - return ret0, ret1 -} - -// CreateVolumeRequest indicates an expected call of CreateVolumeRequest. -func (mr *MockEC2MockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2)(nil).CreateVolumeRequest), arg0) -} - -// CreateVolumeWithContext mocks base method. -func (m *MockEC2) CreateVolumeWithContext(arg0 context.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.Volume) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVolumeWithContext indicates an expected call of CreateVolumeWithContext. -func (mr *MockEC2MockRecorder) CreateVolumeWithContext(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, "CreateVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVolumeWithContext), varargs...) -} - -// CreateVpc mocks base method. -func (m *MockEC2) CreateVpc(arg0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpc", arg0) - ret0, _ := ret[0].(*ec2.CreateVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpc indicates an expected call of CreateVpc. -func (mr *MockEC2MockRecorder) CreateVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2)(nil).CreateVpc), arg0) -} - -// CreateVpcEndpoint mocks base method. -func (m *MockEC2) CreateVpcEndpoint(arg0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpoint", arg0) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint. -func (mr *MockEC2MockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpoint), arg0) -} - -// CreateVpcEndpointConnectionNotification mocks base method. -func (m *MockEC2) CreateVpcEndpointConnectionNotification(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotification", arg0) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpointConnectionNotification indicates an expected call of CreateVpcEndpointConnectionNotification. -func (mr *MockEC2MockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointConnectionNotification), arg0) -} - -// CreateVpcEndpointConnectionNotificationRequest mocks base method. -func (m *MockEC2) CreateVpcEndpointConnectionNotificationRequest(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpcEndpointConnectionNotificationOutput) - return ret0, ret1 -} - -// CreateVpcEndpointConnectionNotificationRequest indicates an expected call of CreateVpcEndpointConnectionNotificationRequest. -func (mr *MockEC2MockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0) -} - -// CreateVpcEndpointConnectionNotificationWithContext mocks base method. -func (m *MockEC2) CreateVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpointConnectionNotificationWithContext indicates an expected call of CreateVpcEndpointConnectionNotificationWithContext. -func (mr *MockEC2MockRecorder) CreateVpcEndpointConnectionNotificationWithContext(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, "CreateVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointConnectionNotificationWithContext), varargs...) -} - -// CreateVpcEndpointRequest mocks base method. -func (m *MockEC2) CreateVpcEndpointRequest(arg0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpcEndpointOutput) - return ret0, ret1 -} - -// CreateVpcEndpointRequest indicates an expected call of CreateVpcEndpointRequest. -func (mr *MockEC2MockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointRequest), arg0) -} - -// CreateVpcEndpointServiceConfiguration mocks base method. -func (m *MockEC2) CreateVpcEndpointServiceConfiguration(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfiguration", arg0) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpointServiceConfiguration indicates an expected call of CreateVpcEndpointServiceConfiguration. -func (mr *MockEC2MockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointServiceConfiguration), arg0) -} - -// CreateVpcEndpointServiceConfigurationRequest mocks base method. -func (m *MockEC2) CreateVpcEndpointServiceConfigurationRequest(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpcEndpointServiceConfigurationOutput) - return ret0, ret1 -} - -// CreateVpcEndpointServiceConfigurationRequest indicates an expected call of CreateVpcEndpointServiceConfigurationRequest. -func (mr *MockEC2MockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0) -} - -// CreateVpcEndpointServiceConfigurationWithContext mocks base method. -func (m *MockEC2) CreateVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpointServiceConfigurationWithContext indicates an expected call of CreateVpcEndpointServiceConfigurationWithContext. -func (mr *MockEC2MockRecorder) CreateVpcEndpointServiceConfigurationWithContext(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, "CreateVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointServiceConfigurationWithContext), varargs...) -} - -// CreateVpcEndpointWithContext mocks base method. -func (m *MockEC2) CreateVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpcEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcEndpointWithContext indicates an expected call of CreateVpcEndpointWithContext. -func (mr *MockEC2MockRecorder) CreateVpcEndpointWithContext(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, "CreateVpcEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpcEndpointWithContext), varargs...) -} - -// CreateVpcPeeringConnection mocks base method. -func (m *MockEC2) CreateVpcPeeringConnection(arg0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0) - ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection. -func (mr *MockEC2MockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2)(nil).CreateVpcPeeringConnection), arg0) -} - -// CreateVpcPeeringConnectionRequest mocks base method. -func (m *MockEC2) CreateVpcPeeringConnectionRequest(arg0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpcPeeringConnectionOutput) - return ret0, ret1 -} - -// CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest. -func (mr *MockEC2MockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpcPeeringConnectionRequest), arg0) -} - -// CreateVpcPeeringConnectionWithContext mocks base method. -func (m *MockEC2) CreateVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcPeeringConnectionWithContext indicates an expected call of CreateVpcPeeringConnectionWithContext. -func (mr *MockEC2MockRecorder) CreateVpcPeeringConnectionWithContext(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, "CreateVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpcPeeringConnectionWithContext), varargs...) -} - -// CreateVpcRequest mocks base method. -func (m *MockEC2) CreateVpcRequest(arg0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpcOutput) - return ret0, ret1 -} - -// CreateVpcRequest indicates an expected call of CreateVpcRequest. -func (mr *MockEC2MockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpcRequest), arg0) -} - -// CreateVpcWithContext mocks base method. -func (m *MockEC2) CreateVpcWithContext(arg0 context.Context, arg1 *ec2.CreateVpcInput, arg2 ...request.Option) (*ec2.CreateVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpcWithContext indicates an expected call of CreateVpcWithContext. -func (mr *MockEC2MockRecorder) CreateVpcWithContext(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, "CreateVpcWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpcWithContext), varargs...) -} - -// CreateVpnConnection mocks base method. -func (m *MockEC2) CreateVpnConnection(arg0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnConnection", arg0) - ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnConnection indicates an expected call of CreateVpnConnection. -func (mr *MockEC2MockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnection), arg0) -} - -// CreateVpnConnectionRequest mocks base method. -func (m *MockEC2) CreateVpnConnectionRequest(arg0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpnConnectionOutput) - return ret0, ret1 -} - -// CreateVpnConnectionRequest indicates an expected call of CreateVpnConnectionRequest. -func (mr *MockEC2MockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnectionRequest), arg0) -} - -// CreateVpnConnectionRoute mocks base method. -func (m *MockEC2) CreateVpnConnectionRoute(arg0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnConnectionRoute", arg0) - ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnConnectionRoute indicates an expected call of CreateVpnConnectionRoute. -func (mr *MockEC2MockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnectionRoute), arg0) -} - -// CreateVpnConnectionRouteRequest mocks base method. -func (m *MockEC2) CreateVpnConnectionRouteRequest(arg0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnConnectionRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpnConnectionRouteOutput) - return ret0, ret1 -} - -// CreateVpnConnectionRouteRequest indicates an expected call of CreateVpnConnectionRouteRequest. -func (mr *MockEC2MockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnectionRouteRequest), arg0) -} - -// CreateVpnConnectionRouteWithContext mocks base method. -func (m *MockEC2) CreateVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpnConnectionRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnConnectionRouteWithContext indicates an expected call of CreateVpnConnectionRouteWithContext. -func (mr *MockEC2MockRecorder) CreateVpnConnectionRouteWithContext(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, "CreateVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnectionRouteWithContext), varargs...) -} - -// CreateVpnConnectionWithContext mocks base method. -func (m *MockEC2) CreateVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.CreateVpnConnectionInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpnConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnConnectionWithContext indicates an expected call of CreateVpnConnectionWithContext. -func (mr *MockEC2MockRecorder) CreateVpnConnectionWithContext(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, "CreateVpnConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpnConnectionWithContext), varargs...) -} - -// CreateVpnGateway mocks base method. -func (m *MockEC2) CreateVpnGateway(arg0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnGateway", arg0) - ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnGateway indicates an expected call of CreateVpnGateway. -func (mr *MockEC2MockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2)(nil).CreateVpnGateway), arg0) -} - -// CreateVpnGatewayRequest mocks base method. -func (m *MockEC2) CreateVpnGatewayRequest(arg0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateVpnGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.CreateVpnGatewayOutput) - return ret0, ret1 -} - -// CreateVpnGatewayRequest indicates an expected call of CreateVpnGatewayRequest. -func (mr *MockEC2MockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2)(nil).CreateVpnGatewayRequest), arg0) -} - -// CreateVpnGatewayWithContext mocks base method. -func (m *MockEC2) CreateVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.CreateVpnGatewayInput, arg2 ...request.Option) (*ec2.CreateVpnGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateVpnGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateVpnGatewayWithContext indicates an expected call of CreateVpnGatewayWithContext. -func (mr *MockEC2MockRecorder) CreateVpnGatewayWithContext(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, "CreateVpnGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).CreateVpnGatewayWithContext), varargs...) -} - -// DeleteCarrierGateway mocks base method. -func (m *MockEC2) DeleteCarrierGateway(arg0 *ec2.DeleteCarrierGatewayInput) (*ec2.DeleteCarrierGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCarrierGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCarrierGateway indicates an expected call of DeleteCarrierGateway. -func (mr *MockEC2MockRecorder) DeleteCarrierGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGateway", reflect.TypeOf((*MockEC2)(nil).DeleteCarrierGateway), arg0) -} - -// DeleteCarrierGatewayRequest mocks base method. -func (m *MockEC2) DeleteCarrierGatewayRequest(arg0 *ec2.DeleteCarrierGatewayInput) (*request.Request, *ec2.DeleteCarrierGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCarrierGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteCarrierGatewayOutput) - return ret0, ret1 -} - -// DeleteCarrierGatewayRequest indicates an expected call of DeleteCarrierGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteCarrierGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCarrierGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteCarrierGatewayRequest), arg0) -} - -// DeleteCarrierGatewayWithContext mocks base method. -func (m *MockEC2) DeleteCarrierGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCarrierGatewayInput, arg2 ...request.Option) (*ec2.DeleteCarrierGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteCarrierGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteCarrierGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCarrierGatewayWithContext indicates an expected call of DeleteCarrierGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteCarrierGatewayWithContext(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, "DeleteCarrierGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteCarrierGatewayWithContext), varargs...) -} - -// DeleteClientVpnEndpoint mocks base method. -func (m *MockEC2) DeleteClientVpnEndpoint(arg0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteClientVpnEndpoint", arg0) - ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteClientVpnEndpoint indicates an expected call of DeleteClientVpnEndpoint. -func (mr *MockEC2MockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnEndpoint), arg0) -} - -// DeleteClientVpnEndpointRequest mocks base method. -func (m *MockEC2) DeleteClientVpnEndpointRequest(arg0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteClientVpnEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteClientVpnEndpointOutput) - return ret0, ret1 -} - -// DeleteClientVpnEndpointRequest indicates an expected call of DeleteClientVpnEndpointRequest. -func (mr *MockEC2MockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnEndpointRequest), arg0) -} - -// DeleteClientVpnEndpointWithContext mocks base method. -func (m *MockEC2) DeleteClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnEndpointInput, arg2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteClientVpnEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteClientVpnEndpointWithContext indicates an expected call of DeleteClientVpnEndpointWithContext. -func (mr *MockEC2MockRecorder) DeleteClientVpnEndpointWithContext(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, "DeleteClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnEndpointWithContext), varargs...) -} - -// DeleteClientVpnRoute mocks base method. -func (m *MockEC2) DeleteClientVpnRoute(arg0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteClientVpnRoute", arg0) - ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteClientVpnRoute indicates an expected call of DeleteClientVpnRoute. -func (mr *MockEC2MockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnRoute), arg0) -} - -// DeleteClientVpnRouteRequest mocks base method. -func (m *MockEC2) DeleteClientVpnRouteRequest(arg0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteClientVpnRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteClientVpnRouteOutput) - return ret0, ret1 -} - -// DeleteClientVpnRouteRequest indicates an expected call of DeleteClientVpnRouteRequest. -func (mr *MockEC2MockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnRouteRequest), arg0) -} - -// DeleteClientVpnRouteWithContext mocks base method. -func (m *MockEC2) DeleteClientVpnRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteClientVpnRouteInput, arg2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteClientVpnRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteClientVpnRouteWithContext indicates an expected call of DeleteClientVpnRouteWithContext. -func (mr *MockEC2MockRecorder) DeleteClientVpnRouteWithContext(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, "DeleteClientVpnRouteWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteClientVpnRouteWithContext), varargs...) -} - -// DeleteCoipCidr mocks base method. -func (m *MockEC2) DeleteCoipCidr(arg0 *ec2.DeleteCoipCidrInput) (*ec2.DeleteCoipCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCoipCidr", arg0) - ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCoipCidr indicates an expected call of DeleteCoipCidr. -func (mr *MockEC2MockRecorder) DeleteCoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidr", reflect.TypeOf((*MockEC2)(nil).DeleteCoipCidr), arg0) -} - -// DeleteCoipCidrRequest mocks base method. -func (m *MockEC2) DeleteCoipCidrRequest(arg0 *ec2.DeleteCoipCidrInput) (*request.Request, *ec2.DeleteCoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteCoipCidrOutput) - return ret0, ret1 -} - -// DeleteCoipCidrRequest indicates an expected call of DeleteCoipCidrRequest. -func (mr *MockEC2MockRecorder) DeleteCoipCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).DeleteCoipCidrRequest), arg0) -} - -// DeleteCoipCidrWithContext mocks base method. -func (m *MockEC2) DeleteCoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipCidrInput, arg2 ...request.Option) (*ec2.DeleteCoipCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteCoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteCoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCoipCidrWithContext indicates an expected call of DeleteCoipCidrWithContext. -func (mr *MockEC2MockRecorder) DeleteCoipCidrWithContext(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, "DeleteCoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteCoipCidrWithContext), varargs...) -} - -// DeleteCoipPool mocks base method. -func (m *MockEC2) DeleteCoipPool(arg0 *ec2.DeleteCoipPoolInput) (*ec2.DeleteCoipPoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCoipPool", arg0) - ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCoipPool indicates an expected call of DeleteCoipPool. -func (mr *MockEC2MockRecorder) DeleteCoipPool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPool", reflect.TypeOf((*MockEC2)(nil).DeleteCoipPool), arg0) -} - -// DeleteCoipPoolRequest mocks base method. -func (m *MockEC2) DeleteCoipPoolRequest(arg0 *ec2.DeleteCoipPoolInput) (*request.Request, *ec2.DeleteCoipPoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCoipPoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteCoipPoolOutput) - return ret0, ret1 -} - -// DeleteCoipPoolRequest indicates an expected call of DeleteCoipPoolRequest. -func (mr *MockEC2MockRecorder) DeleteCoipPoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCoipPoolRequest", reflect.TypeOf((*MockEC2)(nil).DeleteCoipPoolRequest), arg0) -} - -// DeleteCoipPoolWithContext mocks base method. -func (m *MockEC2) DeleteCoipPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteCoipPoolInput, arg2 ...request.Option) (*ec2.DeleteCoipPoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteCoipPoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteCoipPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCoipPoolWithContext indicates an expected call of DeleteCoipPoolWithContext. -func (mr *MockEC2MockRecorder) DeleteCoipPoolWithContext(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, "DeleteCoipPoolWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteCoipPoolWithContext), varargs...) -} - -// DeleteCustomerGateway mocks base method. -func (m *MockEC2) DeleteCustomerGateway(arg0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCustomerGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCustomerGateway indicates an expected call of DeleteCustomerGateway. -func (mr *MockEC2MockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2)(nil).DeleteCustomerGateway), arg0) -} - -// DeleteCustomerGatewayRequest mocks base method. -func (m *MockEC2) DeleteCustomerGatewayRequest(arg0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteCustomerGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteCustomerGatewayOutput) - return ret0, ret1 -} - -// DeleteCustomerGatewayRequest indicates an expected call of DeleteCustomerGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteCustomerGatewayRequest), arg0) -} - -// DeleteCustomerGatewayWithContext mocks base method. -func (m *MockEC2) DeleteCustomerGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteCustomerGatewayInput, arg2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteCustomerGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteCustomerGatewayWithContext indicates an expected call of DeleteCustomerGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteCustomerGatewayWithContext(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, "DeleteCustomerGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteCustomerGatewayWithContext), varargs...) -} - -// DeleteDhcpOptions mocks base method. -func (m *MockEC2) DeleteDhcpOptions(arg0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDhcpOptions", arg0) - ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteDhcpOptions indicates an expected call of DeleteDhcpOptions. -func (mr *MockEC2MockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2)(nil).DeleteDhcpOptions), arg0) -} - -// DeleteDhcpOptionsRequest mocks base method. -func (m *MockEC2) DeleteDhcpOptionsRequest(arg0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteDhcpOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteDhcpOptionsOutput) - return ret0, ret1 -} - -// DeleteDhcpOptionsRequest indicates an expected call of DeleteDhcpOptionsRequest. -func (mr *MockEC2MockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteDhcpOptionsRequest), arg0) -} - -// DeleteDhcpOptionsWithContext mocks base method. -func (m *MockEC2) DeleteDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DeleteDhcpOptionsInput, arg2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteDhcpOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteDhcpOptionsWithContext indicates an expected call of DeleteDhcpOptionsWithContext. -func (mr *MockEC2MockRecorder) DeleteDhcpOptionsWithContext(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, "DeleteDhcpOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteDhcpOptionsWithContext), varargs...) -} - -// DeleteEgressOnlyInternetGateway mocks base method. -func (m *MockEC2) DeleteEgressOnlyInternetGateway(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway. -func (mr *MockEC2MockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2)(nil).DeleteEgressOnlyInternetGateway), arg0) -} - -// DeleteEgressOnlyInternetGatewayRequest mocks base method. -func (m *MockEC2) DeleteEgressOnlyInternetGatewayRequest(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteEgressOnlyInternetGatewayOutput) - return ret0, ret1 -} - -// DeleteEgressOnlyInternetGatewayRequest indicates an expected call of DeleteEgressOnlyInternetGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0) -} - -// DeleteEgressOnlyInternetGatewayWithContext mocks base method. -func (m *MockEC2) DeleteEgressOnlyInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteEgressOnlyInternetGatewayWithContext indicates an expected call of DeleteEgressOnlyInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteEgressOnlyInternetGatewayWithContext(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, "DeleteEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteEgressOnlyInternetGatewayWithContext), varargs...) -} - -// DeleteFleets mocks base method. -func (m *MockEC2) DeleteFleets(arg0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFleets", arg0) - ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFleets indicates an expected call of DeleteFleets. -func (mr *MockEC2MockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2)(nil).DeleteFleets), arg0) -} - -// DeleteFleetsRequest mocks base method. -func (m *MockEC2) DeleteFleetsRequest(arg0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFleetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteFleetsOutput) - return ret0, ret1 -} - -// DeleteFleetsRequest indicates an expected call of DeleteFleetsRequest. -func (mr *MockEC2MockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteFleetsRequest), arg0) -} - -// DeleteFleetsWithContext mocks base method. -func (m *MockEC2) DeleteFleetsWithContext(arg0 context.Context, arg1 *ec2.DeleteFleetsInput, arg2 ...request.Option) (*ec2.DeleteFleetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteFleetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFleetsWithContext indicates an expected call of DeleteFleetsWithContext. -func (mr *MockEC2MockRecorder) DeleteFleetsWithContext(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, "DeleteFleetsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteFleetsWithContext), varargs...) -} - -// DeleteFlowLogs mocks base method. -func (m *MockEC2) DeleteFlowLogs(arg0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFlowLogs", arg0) - ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFlowLogs indicates an expected call of DeleteFlowLogs. -func (mr *MockEC2MockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2)(nil).DeleteFlowLogs), arg0) -} - -// DeleteFlowLogsRequest mocks base method. -func (m *MockEC2) DeleteFlowLogsRequest(arg0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFlowLogsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteFlowLogsOutput) - return ret0, ret1 -} - -// DeleteFlowLogsRequest indicates an expected call of DeleteFlowLogsRequest. -func (mr *MockEC2MockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteFlowLogsRequest), arg0) -} - -// DeleteFlowLogsWithContext mocks base method. -func (m *MockEC2) DeleteFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DeleteFlowLogsInput, arg2 ...request.Option) (*ec2.DeleteFlowLogsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteFlowLogsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFlowLogsWithContext indicates an expected call of DeleteFlowLogsWithContext. -func (mr *MockEC2MockRecorder) DeleteFlowLogsWithContext(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, "DeleteFlowLogsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteFlowLogsWithContext), varargs...) -} - -// DeleteFpgaImage mocks base method. -func (m *MockEC2) DeleteFpgaImage(arg0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFpgaImage", arg0) - ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFpgaImage indicates an expected call of DeleteFpgaImage. -func (mr *MockEC2MockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2)(nil).DeleteFpgaImage), arg0) -} - -// DeleteFpgaImageRequest mocks base method. -func (m *MockEC2) DeleteFpgaImageRequest(arg0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteFpgaImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteFpgaImageOutput) - return ret0, ret1 -} - -// DeleteFpgaImageRequest indicates an expected call of DeleteFpgaImageRequest. -func (mr *MockEC2MockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2)(nil).DeleteFpgaImageRequest), arg0) -} - -// DeleteFpgaImageWithContext mocks base method. -func (m *MockEC2) DeleteFpgaImageWithContext(arg0 context.Context, arg1 *ec2.DeleteFpgaImageInput, arg2 ...request.Option) (*ec2.DeleteFpgaImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteFpgaImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteFpgaImageWithContext indicates an expected call of DeleteFpgaImageWithContext. -func (mr *MockEC2MockRecorder) DeleteFpgaImageWithContext(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, "DeleteFpgaImageWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteFpgaImageWithContext), varargs...) -} - -// DeleteInstanceConnectEndpoint mocks base method. -func (m *MockEC2) DeleteInstanceConnectEndpoint(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*ec2.DeleteInstanceConnectEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpoint", arg0) - ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInstanceConnectEndpoint indicates an expected call of DeleteInstanceConnectEndpoint. -func (mr *MockEC2MockRecorder) DeleteInstanceConnectEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpoint", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceConnectEndpoint), arg0) -} - -// DeleteInstanceConnectEndpointRequest mocks base method. -func (m *MockEC2) DeleteInstanceConnectEndpointRequest(arg0 *ec2.DeleteInstanceConnectEndpointInput) (*request.Request, *ec2.DeleteInstanceConnectEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteInstanceConnectEndpointOutput) - return ret0, ret1 -} - -// DeleteInstanceConnectEndpointRequest indicates an expected call of DeleteInstanceConnectEndpointRequest. -func (mr *MockEC2MockRecorder) DeleteInstanceConnectEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceConnectEndpointRequest", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceConnectEndpointRequest), arg0) -} - -// DeleteInstanceConnectEndpointWithContext mocks base method. -func (m *MockEC2) DeleteInstanceConnectEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceConnectEndpointInput, arg2 ...request.Option) (*ec2.DeleteInstanceConnectEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteInstanceConnectEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteInstanceConnectEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInstanceConnectEndpointWithContext indicates an expected call of DeleteInstanceConnectEndpointWithContext. -func (mr *MockEC2MockRecorder) DeleteInstanceConnectEndpointWithContext(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, "DeleteInstanceConnectEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceConnectEndpointWithContext), varargs...) -} - -// DeleteInstanceEventWindow mocks base method. -func (m *MockEC2) DeleteInstanceEventWindow(arg0 *ec2.DeleteInstanceEventWindowInput) (*ec2.DeleteInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInstanceEventWindow", arg0) - ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInstanceEventWindow indicates an expected call of DeleteInstanceEventWindow. -func (mr *MockEC2MockRecorder) DeleteInstanceEventWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindow", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceEventWindow), arg0) -} - -// DeleteInstanceEventWindowRequest mocks base method. -func (m *MockEC2) DeleteInstanceEventWindowRequest(arg0 *ec2.DeleteInstanceEventWindowInput) (*request.Request, *ec2.DeleteInstanceEventWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInstanceEventWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteInstanceEventWindowOutput) - return ret0, ret1 -} - -// DeleteInstanceEventWindowRequest indicates an expected call of DeleteInstanceEventWindowRequest. -func (mr *MockEC2MockRecorder) DeleteInstanceEventWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInstanceEventWindowRequest", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceEventWindowRequest), arg0) -} - -// DeleteInstanceEventWindowWithContext mocks base method. -func (m *MockEC2) DeleteInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DeleteInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DeleteInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteInstanceEventWindowWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInstanceEventWindowWithContext indicates an expected call of DeleteInstanceEventWindowWithContext. -func (mr *MockEC2MockRecorder) DeleteInstanceEventWindowWithContext(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, "DeleteInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteInstanceEventWindowWithContext), varargs...) -} - -// DeleteInternetGateway mocks base method. -func (m *MockEC2) DeleteInternetGateway(arg0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInternetGateway indicates an expected call of DeleteInternetGateway. -func (mr *MockEC2MockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2)(nil).DeleteInternetGateway), arg0) -} - -// DeleteInternetGatewayRequest mocks base method. -func (m *MockEC2) DeleteInternetGatewayRequest(arg0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteInternetGatewayOutput) - return ret0, ret1 -} - -// DeleteInternetGatewayRequest indicates an expected call of DeleteInternetGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteInternetGatewayRequest), arg0) -} - -// DeleteInternetGatewayWithContext mocks base method. -func (m *MockEC2) DeleteInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteInternetGatewayWithContext indicates an expected call of DeleteInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteInternetGatewayWithContext(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, "DeleteInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteInternetGatewayWithContext), varargs...) -} - -// DeleteIpam mocks base method. -func (m *MockEC2) DeleteIpam(arg0 *ec2.DeleteIpamInput) (*ec2.DeleteIpamOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpam", arg0) - ret0, _ := ret[0].(*ec2.DeleteIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpam indicates an expected call of DeleteIpam. -func (mr *MockEC2MockRecorder) DeleteIpam(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpam", reflect.TypeOf((*MockEC2)(nil).DeleteIpam), arg0) -} - -// DeleteIpamPool mocks base method. -func (m *MockEC2) DeleteIpamPool(arg0 *ec2.DeleteIpamPoolInput) (*ec2.DeleteIpamPoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamPool", arg0) - ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamPool indicates an expected call of DeleteIpamPool. -func (mr *MockEC2MockRecorder) DeleteIpamPool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPool", reflect.TypeOf((*MockEC2)(nil).DeleteIpamPool), arg0) -} - -// DeleteIpamPoolRequest mocks base method. -func (m *MockEC2) DeleteIpamPoolRequest(arg0 *ec2.DeleteIpamPoolInput) (*request.Request, *ec2.DeleteIpamPoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamPoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteIpamPoolOutput) - return ret0, ret1 -} - -// DeleteIpamPoolRequest indicates an expected call of DeleteIpamPoolRequest. -func (mr *MockEC2MockRecorder) DeleteIpamPoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamPoolRequest", reflect.TypeOf((*MockEC2)(nil).DeleteIpamPoolRequest), arg0) -} - -// DeleteIpamPoolWithContext mocks base method. -func (m *MockEC2) DeleteIpamPoolWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamPoolInput, arg2 ...request.Option) (*ec2.DeleteIpamPoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteIpamPoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamPoolWithContext indicates an expected call of DeleteIpamPoolWithContext. -func (mr *MockEC2MockRecorder) DeleteIpamPoolWithContext(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, "DeleteIpamPoolWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteIpamPoolWithContext), varargs...) -} - -// DeleteIpamRequest mocks base method. -func (m *MockEC2) DeleteIpamRequest(arg0 *ec2.DeleteIpamInput) (*request.Request, *ec2.DeleteIpamOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteIpamOutput) - return ret0, ret1 -} - -// DeleteIpamRequest indicates an expected call of DeleteIpamRequest. -func (mr *MockEC2MockRecorder) DeleteIpamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamRequest", reflect.TypeOf((*MockEC2)(nil).DeleteIpamRequest), arg0) -} - -// DeleteIpamResourceDiscovery mocks base method. -func (m *MockEC2) DeleteIpamResourceDiscovery(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*ec2.DeleteIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamResourceDiscovery", arg0) - ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamResourceDiscovery indicates an expected call of DeleteIpamResourceDiscovery. -func (mr *MockEC2MockRecorder) DeleteIpamResourceDiscovery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscovery", reflect.TypeOf((*MockEC2)(nil).DeleteIpamResourceDiscovery), arg0) -} - -// DeleteIpamResourceDiscoveryRequest mocks base method. -func (m *MockEC2) DeleteIpamResourceDiscoveryRequest(arg0 *ec2.DeleteIpamResourceDiscoveryInput) (*request.Request, *ec2.DeleteIpamResourceDiscoveryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteIpamResourceDiscoveryOutput) - return ret0, ret1 -} - -// DeleteIpamResourceDiscoveryRequest indicates an expected call of DeleteIpamResourceDiscoveryRequest. -func (mr *MockEC2MockRecorder) DeleteIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2)(nil).DeleteIpamResourceDiscoveryRequest), arg0) -} - -// DeleteIpamResourceDiscoveryWithContext mocks base method. -func (m *MockEC2) DeleteIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DeleteIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteIpamResourceDiscoveryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamResourceDiscoveryWithContext indicates an expected call of DeleteIpamResourceDiscoveryWithContext. -func (mr *MockEC2MockRecorder) DeleteIpamResourceDiscoveryWithContext(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, "DeleteIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteIpamResourceDiscoveryWithContext), varargs...) -} - -// DeleteIpamScope mocks base method. -func (m *MockEC2) DeleteIpamScope(arg0 *ec2.DeleteIpamScopeInput) (*ec2.DeleteIpamScopeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamScope", arg0) - ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamScope indicates an expected call of DeleteIpamScope. -func (mr *MockEC2MockRecorder) DeleteIpamScope(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScope", reflect.TypeOf((*MockEC2)(nil).DeleteIpamScope), arg0) -} - -// DeleteIpamScopeRequest mocks base method. -func (m *MockEC2) DeleteIpamScopeRequest(arg0 *ec2.DeleteIpamScopeInput) (*request.Request, *ec2.DeleteIpamScopeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteIpamScopeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteIpamScopeOutput) - return ret0, ret1 -} - -// DeleteIpamScopeRequest indicates an expected call of DeleteIpamScopeRequest. -func (mr *MockEC2MockRecorder) DeleteIpamScopeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIpamScopeRequest", reflect.TypeOf((*MockEC2)(nil).DeleteIpamScopeRequest), arg0) -} - -// DeleteIpamScopeWithContext mocks base method. -func (m *MockEC2) DeleteIpamScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamScopeInput, arg2 ...request.Option) (*ec2.DeleteIpamScopeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteIpamScopeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamScopeWithContext indicates an expected call of DeleteIpamScopeWithContext. -func (mr *MockEC2MockRecorder) DeleteIpamScopeWithContext(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, "DeleteIpamScopeWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteIpamScopeWithContext), varargs...) -} - -// DeleteIpamWithContext mocks base method. -func (m *MockEC2) DeleteIpamWithContext(arg0 context.Context, arg1 *ec2.DeleteIpamInput, arg2 ...request.Option) (*ec2.DeleteIpamOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteIpamWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteIpamWithContext indicates an expected call of DeleteIpamWithContext. -func (mr *MockEC2MockRecorder) DeleteIpamWithContext(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, "DeleteIpamWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteIpamWithContext), varargs...) -} - -// DeleteKeyPair mocks base method. -func (m *MockEC2) DeleteKeyPair(arg0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteKeyPair", arg0) - ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteKeyPair indicates an expected call of DeleteKeyPair. -func (mr *MockEC2MockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2)(nil).DeleteKeyPair), arg0) -} - -// DeleteKeyPairRequest mocks base method. -func (m *MockEC2) DeleteKeyPairRequest(arg0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteKeyPairRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteKeyPairOutput) - return ret0, ret1 -} - -// DeleteKeyPairRequest indicates an expected call of DeleteKeyPairRequest. -func (mr *MockEC2MockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2)(nil).DeleteKeyPairRequest), arg0) -} - -// DeleteKeyPairWithContext mocks base method. -func (m *MockEC2) DeleteKeyPairWithContext(arg0 context.Context, arg1 *ec2.DeleteKeyPairInput, arg2 ...request.Option) (*ec2.DeleteKeyPairOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteKeyPairWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteKeyPairWithContext indicates an expected call of DeleteKeyPairWithContext. -func (mr *MockEC2MockRecorder) DeleteKeyPairWithContext(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, "DeleteKeyPairWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteKeyPairWithContext), varargs...) -} - -// DeleteLaunchTemplate mocks base method. -func (m *MockEC2) DeleteLaunchTemplate(arg0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLaunchTemplate", arg0) - ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplate), arg0) -} - -// DeleteLaunchTemplateRequest mocks base method. -func (m *MockEC2) DeleteLaunchTemplateRequest(arg0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLaunchTemplateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateOutput) - return ret0, ret1 -} - -// DeleteLaunchTemplateRequest indicates an expected call of DeleteLaunchTemplateRequest. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplateRequest), arg0) -} - -// DeleteLaunchTemplateVersions mocks base method. -func (m *MockEC2) DeleteLaunchTemplateVersions(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", arg0) - ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplateVersions), arg0) -} - -// DeleteLaunchTemplateVersionsRequest mocks base method. -func (m *MockEC2) DeleteLaunchTemplateVersionsRequest(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateVersionsOutput) - return ret0, ret1 -} - -// DeleteLaunchTemplateVersionsRequest indicates an expected call of DeleteLaunchTemplateVersionsRequest. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplateVersionsRequest), arg0) -} - -// DeleteLaunchTemplateVersionsWithContext mocks base method. -func (m *MockEC2) DeleteLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLaunchTemplateVersionsWithContext indicates an expected call of DeleteLaunchTemplateVersionsWithContext. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplateVersionsWithContext(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, "DeleteLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplateVersionsWithContext), varargs...) -} - -// DeleteLaunchTemplateWithContext mocks base method. -func (m *MockEC2) DeleteLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLaunchTemplateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLaunchTemplateWithContext indicates an expected call of DeleteLaunchTemplateWithContext. -func (mr *MockEC2MockRecorder) DeleteLaunchTemplateWithContext(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, "DeleteLaunchTemplateWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLaunchTemplateWithContext), varargs...) -} - -// DeleteLocalGatewayRoute mocks base method. -func (m *MockEC2) DeleteLocalGatewayRoute(arg0 *ec2.DeleteLocalGatewayRouteInput) (*ec2.DeleteLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRoute indicates an expected call of DeleteLocalGatewayRoute. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRoute", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRoute), arg0) -} - -// DeleteLocalGatewayRouteRequest mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteRequest(arg0 *ec2.DeleteLocalGatewayRouteInput) (*request.Request, *ec2.DeleteLocalGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteOutput) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteRequest indicates an expected call of DeleteLocalGatewayRouteRequest. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteRequest), arg0) -} - -// DeleteLocalGatewayRouteTable mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTable(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*ec2.DeleteLocalGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTable indicates an expected call of DeleteLocalGatewayRouteTable. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTable), arg0) -} - -// DeleteLocalGatewayRouteTableRequest mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableRequest(arg0 *ec2.DeleteLocalGatewayRouteTableInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableOutput) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableRequest indicates an expected call of DeleteLocalGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableRequest), arg0) -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", arg0) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociation), arg0) -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationRequest), arg0) -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext indicates an expected call of DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext(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, "DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVirtualInterfaceGroupAssociationWithContext), varargs...) -} - -// DeleteLocalGatewayRouteTableVpcAssociation mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVpcAssociation(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociation", arg0) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVpcAssociation indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociation. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVpcAssociation), arg0) -} - -// DeleteLocalGatewayRouteTableVpcAssociationRequest mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput) (*request.Request, *ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVpcAssociationRequest indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationRequest. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVpcAssociationRequest), arg0) -} - -// DeleteLocalGatewayRouteTableVpcAssociationWithContext mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableVpcAssociationInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableVpcAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableVpcAssociationWithContext indicates an expected call of DeleteLocalGatewayRouteTableVpcAssociationWithContext. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableVpcAssociationWithContext(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, "DeleteLocalGatewayRouteTableVpcAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableVpcAssociationWithContext), varargs...) -} - -// DeleteLocalGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteTableWithContext indicates an expected call of DeleteLocalGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteTableWithContext(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, "DeleteLocalGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteTableWithContext), varargs...) -} - -// DeleteLocalGatewayRouteWithContext mocks base method. -func (m *MockEC2) DeleteLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLocalGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteLocalGatewayRouteWithContext indicates an expected call of DeleteLocalGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) DeleteLocalGatewayRouteWithContext(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, "DeleteLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteLocalGatewayRouteWithContext), varargs...) -} - -// DeleteManagedPrefixList mocks base method. -func (m *MockEC2) DeleteManagedPrefixList(arg0 *ec2.DeleteManagedPrefixListInput) (*ec2.DeleteManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteManagedPrefixList", arg0) - ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteManagedPrefixList indicates an expected call of DeleteManagedPrefixList. -func (mr *MockEC2MockRecorder) DeleteManagedPrefixList(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixList", reflect.TypeOf((*MockEC2)(nil).DeleteManagedPrefixList), arg0) -} - -// DeleteManagedPrefixListRequest mocks base method. -func (m *MockEC2) DeleteManagedPrefixListRequest(arg0 *ec2.DeleteManagedPrefixListInput) (*request.Request, *ec2.DeleteManagedPrefixListOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteManagedPrefixListRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteManagedPrefixListOutput) - return ret0, ret1 -} - -// DeleteManagedPrefixListRequest indicates an expected call of DeleteManagedPrefixListRequest. -func (mr *MockEC2MockRecorder) DeleteManagedPrefixListRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedPrefixListRequest", reflect.TypeOf((*MockEC2)(nil).DeleteManagedPrefixListRequest), arg0) -} - -// DeleteManagedPrefixListWithContext mocks base method. -func (m *MockEC2) DeleteManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.DeleteManagedPrefixListInput, arg2 ...request.Option) (*ec2.DeleteManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteManagedPrefixListWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteManagedPrefixListWithContext indicates an expected call of DeleteManagedPrefixListWithContext. -func (mr *MockEC2MockRecorder) DeleteManagedPrefixListWithContext(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, "DeleteManagedPrefixListWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteManagedPrefixListWithContext), varargs...) -} - -// DeleteNatGateway mocks base method. -func (m *MockEC2) DeleteNatGateway(arg0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNatGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNatGateway indicates an expected call of DeleteNatGateway. -func (mr *MockEC2MockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2)(nil).DeleteNatGateway), arg0) -} - -// DeleteNatGatewayRequest mocks base method. -func (m *MockEC2) DeleteNatGatewayRequest(arg0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNatGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNatGatewayOutput) - return ret0, ret1 -} - -// DeleteNatGatewayRequest indicates an expected call of DeleteNatGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNatGatewayRequest), arg0) -} - -// DeleteNatGatewayWithContext mocks base method. -func (m *MockEC2) DeleteNatGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...request.Option) (*ec2.DeleteNatGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNatGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNatGatewayWithContext indicates an expected call of DeleteNatGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteNatGatewayWithContext(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, "DeleteNatGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNatGatewayWithContext), varargs...) -} - -// DeleteNetworkAcl mocks base method. -func (m *MockEC2) DeleteNetworkAcl(arg0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkAcl", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkAcl indicates an expected call of DeleteNetworkAcl. -func (mr *MockEC2MockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAcl), arg0) -} - -// DeleteNetworkAclEntry mocks base method. -func (m *MockEC2) DeleteNetworkAclEntry(arg0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkAclEntry", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkAclEntry indicates an expected call of DeleteNetworkAclEntry. -func (mr *MockEC2MockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAclEntry), arg0) -} - -// DeleteNetworkAclEntryRequest mocks base method. -func (m *MockEC2) DeleteNetworkAclEntryRequest(arg0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkAclEntryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkAclEntryOutput) - return ret0, ret1 -} - -// DeleteNetworkAclEntryRequest indicates an expected call of DeleteNetworkAclEntryRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAclEntryRequest), arg0) -} - -// DeleteNetworkAclEntryWithContext mocks base method. -func (m *MockEC2) DeleteNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclEntryInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkAclEntryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkAclEntryWithContext indicates an expected call of DeleteNetworkAclEntryWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkAclEntryWithContext(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, "DeleteNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAclEntryWithContext), varargs...) -} - -// DeleteNetworkAclRequest mocks base method. -func (m *MockEC2) DeleteNetworkAclRequest(arg0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkAclRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkAclOutput) - return ret0, ret1 -} - -// DeleteNetworkAclRequest indicates an expected call of DeleteNetworkAclRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAclRequest), arg0) -} - -// DeleteNetworkAclWithContext mocks base method. -func (m *MockEC2) DeleteNetworkAclWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkAclInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkAclWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkAclWithContext indicates an expected call of DeleteNetworkAclWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkAclWithContext(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, "DeleteNetworkAclWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkAclWithContext), varargs...) -} - -// DeleteNetworkInsightsAccessScope mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScope(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScope", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScope indicates an expected call of DeleteNetworkInsightsAccessScope. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScope(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScope", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScope), arg0) -} - -// DeleteNetworkInsightsAccessScopeAnalysis mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScopeAnalysis(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysis", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScopeAnalysis indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysis. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScopeAnalysis), arg0) -} - -// DeleteNetworkInsightsAccessScopeAnalysisRequest mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysisRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScopeAnalysisRequest), arg0) -} - -// DeleteNetworkInsightsAccessScopeAnalysisWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeAnalysisWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeAnalysisOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScopeAnalysisWithContext indicates an expected call of DeleteNetworkInsightsAccessScopeAnalysisWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScopeAnalysisWithContext(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, "DeleteNetworkInsightsAccessScopeAnalysisWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScopeAnalysisWithContext), varargs...) -} - -// DeleteNetworkInsightsAccessScopeRequest mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScopeRequest(arg0 *ec2.DeleteNetworkInsightsAccessScopeInput) (*request.Request, *ec2.DeleteNetworkInsightsAccessScopeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkInsightsAccessScopeOutput) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScopeRequest indicates an expected call of DeleteNetworkInsightsAccessScopeRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScopeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAccessScopeRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScopeRequest), arg0) -} - -// DeleteNetworkInsightsAccessScopeWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAccessScopeWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInsightsAccessScopeInput, arg2 ...request.Option) (*ec2.DeleteNetworkInsightsAccessScopeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkInsightsAccessScopeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkInsightsAccessScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInsightsAccessScopeWithContext indicates an expected call of DeleteNetworkInsightsAccessScopeWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkInsightsAccessScopeWithContext(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, "DeleteNetworkInsightsAccessScopeWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAccessScopeWithContext), varargs...) -} - -// DeleteNetworkInsightsAnalysis mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAnalysis), arg0) -} - -// DeleteNetworkInsightsAnalysisRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsAnalysisRequest), arg0) -} - -// DeleteNetworkInsightsAnalysisWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInsightsAnalysisWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DeleteNetworkInsightsAnalysisWithContext), varargs...) -} - -// DeleteNetworkInsightsPath mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteNetworkInsightsPath(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPath", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsPath), arg0) -} - -// DeleteNetworkInsightsPathRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteNetworkInsightsPathRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInsightsPathRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInsightsPathRequest), arg0) -} - -// DeleteNetworkInsightsPathWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInsightsPathWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DeleteNetworkInsightsPathWithContext), varargs...) -} - -// DeleteNetworkInterface mocks base method. -func (m *MockEC2) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface. -func (mr *MockEC2MockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterface), arg0) -} - -// DeleteNetworkInterfacePermission mocks base method. -func (m *MockEC2) DeleteNetworkInterfacePermission(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermission", arg0) - ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInterfacePermission indicates an expected call of DeleteNetworkInterfacePermission. -func (mr *MockEC2MockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterfacePermission), arg0) -} - -// DeleteNetworkInterfacePermissionRequest mocks base method. -func (m *MockEC2) DeleteNetworkInterfacePermissionRequest(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkInterfacePermissionOutput) - return ret0, ret1 -} - -// DeleteNetworkInterfacePermissionRequest indicates an expected call of DeleteNetworkInterfacePermissionRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterfacePermissionRequest), arg0) -} - -// DeleteNetworkInterfacePermissionWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInterfacePermissionWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInterfacePermissionWithContext indicates an expected call of DeleteNetworkInterfacePermissionWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkInterfacePermissionWithContext(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, "DeleteNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterfacePermissionWithContext), varargs...) -} - -// DeleteNetworkInterfaceRequest mocks base method. -func (m *MockEC2) DeleteNetworkInterfaceRequest(arg0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteNetworkInterfaceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteNetworkInterfaceOutput) - return ret0, ret1 -} - -// DeleteNetworkInterfaceRequest indicates an expected call of DeleteNetworkInterfaceRequest. -func (mr *MockEC2MockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterfaceRequest), arg0) -} - -// DeleteNetworkInterfaceWithContext mocks base method. -func (m *MockEC2) DeleteNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DeleteNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteNetworkInterfaceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteNetworkInterfaceWithContext indicates an expected call of DeleteNetworkInterfaceWithContext. -func (mr *MockEC2MockRecorder) DeleteNetworkInterfaceWithContext(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, "DeleteNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteNetworkInterfaceWithContext), varargs...) -} - -// DeletePlacementGroup mocks base method. -func (m *MockEC2) DeletePlacementGroup(arg0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePlacementGroup", arg0) - ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePlacementGroup indicates an expected call of DeletePlacementGroup. -func (mr *MockEC2MockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2)(nil).DeletePlacementGroup), arg0) -} - -// DeletePlacementGroupRequest mocks base method. -func (m *MockEC2) DeletePlacementGroupRequest(arg0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePlacementGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeletePlacementGroupOutput) - return ret0, ret1 -} - -// DeletePlacementGroupRequest indicates an expected call of DeletePlacementGroupRequest. -func (mr *MockEC2MockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2)(nil).DeletePlacementGroupRequest), arg0) -} - -// DeletePlacementGroupWithContext mocks base method. -func (m *MockEC2) DeletePlacementGroupWithContext(arg0 context.Context, arg1 *ec2.DeletePlacementGroupInput, arg2 ...request.Option) (*ec2.DeletePlacementGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeletePlacementGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePlacementGroupWithContext indicates an expected call of DeletePlacementGroupWithContext. -func (mr *MockEC2MockRecorder) DeletePlacementGroupWithContext(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, "DeletePlacementGroupWithContext", reflect.TypeOf((*MockEC2)(nil).DeletePlacementGroupWithContext), varargs...) -} - -// DeletePublicIpv4Pool mocks base method. -func (m *MockEC2) DeletePublicIpv4Pool(arg0 *ec2.DeletePublicIpv4PoolInput) (*ec2.DeletePublicIpv4PoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePublicIpv4Pool", arg0) - ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePublicIpv4Pool indicates an expected call of DeletePublicIpv4Pool. -func (mr *MockEC2MockRecorder) DeletePublicIpv4Pool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4Pool", reflect.TypeOf((*MockEC2)(nil).DeletePublicIpv4Pool), arg0) -} - -// DeletePublicIpv4PoolRequest mocks base method. -func (m *MockEC2) DeletePublicIpv4PoolRequest(arg0 *ec2.DeletePublicIpv4PoolInput) (*request.Request, *ec2.DeletePublicIpv4PoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeletePublicIpv4PoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeletePublicIpv4PoolOutput) - return ret0, ret1 -} - -// DeletePublicIpv4PoolRequest indicates an expected call of DeletePublicIpv4PoolRequest. -func (mr *MockEC2MockRecorder) DeletePublicIpv4PoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicIpv4PoolRequest", reflect.TypeOf((*MockEC2)(nil).DeletePublicIpv4PoolRequest), arg0) -} - -// DeletePublicIpv4PoolWithContext mocks base method. -func (m *MockEC2) DeletePublicIpv4PoolWithContext(arg0 context.Context, arg1 *ec2.DeletePublicIpv4PoolInput, arg2 ...request.Option) (*ec2.DeletePublicIpv4PoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeletePublicIpv4PoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeletePublicIpv4PoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeletePublicIpv4PoolWithContext indicates an expected call of DeletePublicIpv4PoolWithContext. -func (mr *MockEC2MockRecorder) DeletePublicIpv4PoolWithContext(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, "DeletePublicIpv4PoolWithContext", reflect.TypeOf((*MockEC2)(nil).DeletePublicIpv4PoolWithContext), varargs...) -} - -// DeleteQueuedReservedInstances mocks base method. -func (m *MockEC2) DeleteQueuedReservedInstances(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*ec2.DeleteQueuedReservedInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteQueuedReservedInstances", arg0) - ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteQueuedReservedInstances indicates an expected call of DeleteQueuedReservedInstances. -func (mr *MockEC2MockRecorder) DeleteQueuedReservedInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstances", reflect.TypeOf((*MockEC2)(nil).DeleteQueuedReservedInstances), arg0) -} - -// DeleteQueuedReservedInstancesRequest mocks base method. -func (m *MockEC2) DeleteQueuedReservedInstancesRequest(arg0 *ec2.DeleteQueuedReservedInstancesInput) (*request.Request, *ec2.DeleteQueuedReservedInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteQueuedReservedInstancesOutput) - return ret0, ret1 -} - -// DeleteQueuedReservedInstancesRequest indicates an expected call of DeleteQueuedReservedInstancesRequest. -func (mr *MockEC2MockRecorder) DeleteQueuedReservedInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DeleteQueuedReservedInstancesRequest), arg0) -} - -// DeleteQueuedReservedInstancesWithContext mocks base method. -func (m *MockEC2) DeleteQueuedReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DeleteQueuedReservedInstancesInput, arg2 ...request.Option) (*ec2.DeleteQueuedReservedInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteQueuedReservedInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteQueuedReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteQueuedReservedInstancesWithContext indicates an expected call of DeleteQueuedReservedInstancesWithContext. -func (mr *MockEC2MockRecorder) DeleteQueuedReservedInstancesWithContext(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, "DeleteQueuedReservedInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteQueuedReservedInstancesWithContext), varargs...) -} - -// DeleteRoute mocks base method. -func (m *MockEC2) DeleteRoute(arg0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRoute", arg0) - ret0, _ := ret[0].(*ec2.DeleteRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteRoute indicates an expected call of DeleteRoute. -func (mr *MockEC2MockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2)(nil).DeleteRoute), arg0) -} - -// DeleteRouteRequest mocks base method. -func (m *MockEC2) DeleteRouteRequest(arg0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteRouteOutput) - return ret0, ret1 -} - -// DeleteRouteRequest indicates an expected call of DeleteRouteRequest. -func (mr *MockEC2MockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2)(nil).DeleteRouteRequest), arg0) -} - -// DeleteRouteTable mocks base method. -func (m *MockEC2) DeleteRouteTable(arg0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRouteTable", arg0) - ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteRouteTable indicates an expected call of DeleteRouteTable. -func (mr *MockEC2MockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2)(nil).DeleteRouteTable), arg0) -} - -// DeleteRouteTableRequest mocks base method. -func (m *MockEC2) DeleteRouteTableRequest(arg0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteRouteTableOutput) - return ret0, ret1 -} - -// DeleteRouteTableRequest indicates an expected call of DeleteRouteTableRequest. -func (mr *MockEC2MockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).DeleteRouteTableRequest), arg0) -} - -// DeleteRouteTableWithContext mocks base method. -func (m *MockEC2) DeleteRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...request.Option) (*ec2.DeleteRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteRouteTableWithContext indicates an expected call of DeleteRouteTableWithContext. -func (mr *MockEC2MockRecorder) DeleteRouteTableWithContext(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, "DeleteRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteRouteTableWithContext), varargs...) -} - -// DeleteRouteWithContext mocks base method. -func (m *MockEC2) DeleteRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteRouteInput, arg2 ...request.Option) (*ec2.DeleteRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteRouteWithContext indicates an expected call of DeleteRouteWithContext. -func (mr *MockEC2MockRecorder) DeleteRouteWithContext(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, "DeleteRouteWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteRouteWithContext), varargs...) -} - -// DeleteSecurityGroup mocks base method. -func (m *MockEC2) DeleteSecurityGroup(arg0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0) - ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup. -func (mr *MockEC2MockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2)(nil).DeleteSecurityGroup), arg0) -} - -// DeleteSecurityGroupRequest mocks base method. -func (m *MockEC2) DeleteSecurityGroupRequest(arg0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSecurityGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteSecurityGroupOutput) - return ret0, ret1 -} - -// DeleteSecurityGroupRequest indicates an expected call of DeleteSecurityGroupRequest. -func (mr *MockEC2MockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2)(nil).DeleteSecurityGroupRequest), arg0) -} - -// DeleteSecurityGroupWithContext mocks base method. -func (m *MockEC2) DeleteSecurityGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSecurityGroupWithContext indicates an expected call of DeleteSecurityGroupWithContext. -func (mr *MockEC2MockRecorder) DeleteSecurityGroupWithContext(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, "DeleteSecurityGroupWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSecurityGroupWithContext), varargs...) -} - -// DeleteSnapshot mocks base method. -func (m *MockEC2) DeleteSnapshot(arg0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSnapshot", arg0) - ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSnapshot indicates an expected call of DeleteSnapshot. -func (mr *MockEC2MockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2)(nil).DeleteSnapshot), arg0) -} - -// DeleteSnapshotRequest mocks base method. -func (m *MockEC2) DeleteSnapshotRequest(arg0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteSnapshotOutput) - return ret0, ret1 -} - -// DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest. -func (mr *MockEC2MockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2)(nil).DeleteSnapshotRequest), arg0) -} - -// DeleteSnapshotWithContext mocks base method. -func (m *MockEC2) DeleteSnapshotWithContext(arg0 context.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext. -func (mr *MockEC2MockRecorder) DeleteSnapshotWithContext(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, "DeleteSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSnapshotWithContext), varargs...) -} - -// DeleteSpotDatafeedSubscription mocks base method. -func (m *MockEC2) DeleteSpotDatafeedSubscription(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscription", arg0) - ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSpotDatafeedSubscription indicates an expected call of DeleteSpotDatafeedSubscription. -func (mr *MockEC2MockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2)(nil).DeleteSpotDatafeedSubscription), arg0) -} - -// DeleteSpotDatafeedSubscriptionRequest mocks base method. -func (m *MockEC2) DeleteSpotDatafeedSubscriptionRequest(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteSpotDatafeedSubscriptionOutput) - return ret0, ret1 -} - -// DeleteSpotDatafeedSubscriptionRequest indicates an expected call of DeleteSpotDatafeedSubscriptionRequest. -func (mr *MockEC2MockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0) -} - -// DeleteSpotDatafeedSubscriptionWithContext mocks base method. -func (m *MockEC2) DeleteSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DeleteSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSpotDatafeedSubscriptionWithContext indicates an expected call of DeleteSpotDatafeedSubscriptionWithContext. -func (mr *MockEC2MockRecorder) DeleteSpotDatafeedSubscriptionWithContext(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, "DeleteSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSpotDatafeedSubscriptionWithContext), varargs...) -} - -// DeleteSubnet mocks base method. -func (m *MockEC2) DeleteSubnet(arg0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubnet", arg0) - ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubnet indicates an expected call of DeleteSubnet. -func (mr *MockEC2MockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2)(nil).DeleteSubnet), arg0) -} - -// DeleteSubnetCidrReservation mocks base method. -func (m *MockEC2) DeleteSubnetCidrReservation(arg0 *ec2.DeleteSubnetCidrReservationInput) (*ec2.DeleteSubnetCidrReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubnetCidrReservation", arg0) - ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubnetCidrReservation indicates an expected call of DeleteSubnetCidrReservation. -func (mr *MockEC2MockRecorder) DeleteSubnetCidrReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservation", reflect.TypeOf((*MockEC2)(nil).DeleteSubnetCidrReservation), arg0) -} - -// DeleteSubnetCidrReservationRequest mocks base method. -func (m *MockEC2) DeleteSubnetCidrReservationRequest(arg0 *ec2.DeleteSubnetCidrReservationInput) (*request.Request, *ec2.DeleteSubnetCidrReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteSubnetCidrReservationOutput) - return ret0, ret1 -} - -// DeleteSubnetCidrReservationRequest indicates an expected call of DeleteSubnetCidrReservationRequest. -func (mr *MockEC2MockRecorder) DeleteSubnetCidrReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetCidrReservationRequest", reflect.TypeOf((*MockEC2)(nil).DeleteSubnetCidrReservationRequest), arg0) -} - -// DeleteSubnetCidrReservationWithContext mocks base method. -func (m *MockEC2) DeleteSubnetCidrReservationWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetCidrReservationInput, arg2 ...request.Option) (*ec2.DeleteSubnetCidrReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSubnetCidrReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteSubnetCidrReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubnetCidrReservationWithContext indicates an expected call of DeleteSubnetCidrReservationWithContext. -func (mr *MockEC2MockRecorder) DeleteSubnetCidrReservationWithContext(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, "DeleteSubnetCidrReservationWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSubnetCidrReservationWithContext), varargs...) -} - -// DeleteSubnetRequest mocks base method. -func (m *MockEC2) DeleteSubnetRequest(arg0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubnetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteSubnetOutput) - return ret0, ret1 -} - -// DeleteSubnetRequest indicates an expected call of DeleteSubnetRequest. -func (mr *MockEC2MockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2)(nil).DeleteSubnetRequest), arg0) -} - -// DeleteSubnetWithContext mocks base method. -func (m *MockEC2) DeleteSubnetWithContext(arg0 context.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...request.Option) (*ec2.DeleteSubnetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSubnetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubnetWithContext indicates an expected call of DeleteSubnetWithContext. -func (mr *MockEC2MockRecorder) DeleteSubnetWithContext(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, "DeleteSubnetWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteSubnetWithContext), varargs...) -} - -// DeleteTags mocks base method. -func (m *MockEC2) DeleteTags(arg0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTags", arg0) - ret0, _ := ret[0].(*ec2.DeleteTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTags indicates an expected call of DeleteTags. -func (mr *MockEC2MockRecorder) DeleteTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2)(nil).DeleteTags), arg0) -} - -// DeleteTagsRequest mocks base method. -func (m *MockEC2) DeleteTagsRequest(arg0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTagsOutput) - return ret0, ret1 -} - -// DeleteTagsRequest indicates an expected call of DeleteTagsRequest. -func (mr *MockEC2MockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTagsRequest), arg0) -} - -// DeleteTagsWithContext mocks base method. -func (m *MockEC2) DeleteTagsWithContext(arg0 context.Context, arg1 *ec2.DeleteTagsInput, arg2 ...request.Option) (*ec2.DeleteTagsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext. -func (mr *MockEC2MockRecorder) DeleteTagsWithContext(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, "DeleteTagsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTagsWithContext), varargs...) -} - -// DeleteTrafficMirrorFilter mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilter(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilter", arg0) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilter indicates an expected call of DeleteTrafficMirrorFilter. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilter), arg0) -} - -// DeleteTrafficMirrorFilterRequest mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilterRequest(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterOutput) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilterRequest indicates an expected call of DeleteTrafficMirrorFilterRequest. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilterRequest), arg0) -} - -// DeleteTrafficMirrorFilterRule mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilterRule(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRule", arg0) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilterRule indicates an expected call of DeleteTrafficMirrorFilterRule. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilterRule), arg0) -} - -// DeleteTrafficMirrorFilterRuleRequest mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilterRuleRequest(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterRuleOutput) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilterRuleRequest indicates an expected call of DeleteTrafficMirrorFilterRuleRequest. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0) -} - -// DeleteTrafficMirrorFilterRuleWithContext mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilterRuleWithContext indicates an expected call of DeleteTrafficMirrorFilterRuleWithContext. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilterRuleWithContext(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, "DeleteTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilterRuleWithContext), varargs...) -} - -// DeleteTrafficMirrorFilterWithContext mocks base method. -func (m *MockEC2) DeleteTrafficMirrorFilterWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorFilterWithContext indicates an expected call of DeleteTrafficMirrorFilterWithContext. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorFilterWithContext(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, "DeleteTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorFilterWithContext), varargs...) -} - -// DeleteTrafficMirrorSession mocks base method. -func (m *MockEC2) DeleteTrafficMirrorSession(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorSession", arg0) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorSession indicates an expected call of DeleteTrafficMirrorSession. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorSession), arg0) -} - -// DeleteTrafficMirrorSessionRequest mocks base method. -func (m *MockEC2) DeleteTrafficMirrorSessionRequest(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorSessionOutput) - return ret0, ret1 -} - -// DeleteTrafficMirrorSessionRequest indicates an expected call of DeleteTrafficMirrorSessionRequest. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorSessionRequest), arg0) -} - -// DeleteTrafficMirrorSessionWithContext mocks base method. -func (m *MockEC2) DeleteTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorSessionWithContext indicates an expected call of DeleteTrafficMirrorSessionWithContext. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorSessionWithContext(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, "DeleteTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorSessionWithContext), varargs...) -} - -// DeleteTrafficMirrorTarget mocks base method. -func (m *MockEC2) DeleteTrafficMirrorTarget(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorTarget", arg0) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorTarget indicates an expected call of DeleteTrafficMirrorTarget. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorTarget), arg0) -} - -// DeleteTrafficMirrorTargetRequest mocks base method. -func (m *MockEC2) DeleteTrafficMirrorTargetRequest(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorTargetOutput) - return ret0, ret1 -} - -// DeleteTrafficMirrorTargetRequest indicates an expected call of DeleteTrafficMirrorTargetRequest. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorTargetRequest), arg0) -} - -// DeleteTrafficMirrorTargetWithContext mocks base method. -func (m *MockEC2) DeleteTrafficMirrorTargetWithContext(arg0 context.Context, arg1 *ec2.DeleteTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTrafficMirrorTargetWithContext indicates an expected call of DeleteTrafficMirrorTargetWithContext. -func (mr *MockEC2MockRecorder) DeleteTrafficMirrorTargetWithContext(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, "DeleteTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTrafficMirrorTargetWithContext), varargs...) -} - -// DeleteTransitGateway mocks base method. -func (m *MockEC2) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGateway indicates an expected call of DeleteTransitGateway. -func (mr *MockEC2MockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGateway), arg0) -} - -// DeleteTransitGatewayConnect mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteTransitGatewayConnect(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnect", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayConnect), arg0) -} - -// DeleteTransitGatewayConnectPeer mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteTransitGatewayConnectPeer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeer", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayConnectPeer), arg0) -} - -// DeleteTransitGatewayConnectPeerRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteTransitGatewayConnectPeerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectPeerRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayConnectPeerRequest), arg0) -} - -// DeleteTransitGatewayConnectPeerWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayConnectPeerWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DeleteTransitGatewayConnectPeerWithContext), varargs...) -} - -// DeleteTransitGatewayConnectRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DeleteTransitGatewayConnectRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayConnectRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayConnectRequest), arg0) -} - -// DeleteTransitGatewayConnectWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayConnectWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DeleteTransitGatewayConnectWithContext), varargs...) -} - -// DeleteTransitGatewayMulticastDomain mocks base method. -func (m *MockEC2) DeleteTransitGatewayMulticastDomain(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomain", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayMulticastDomain indicates an expected call of DeleteTransitGatewayMulticastDomain. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayMulticastDomain), arg0) -} - -// DeleteTransitGatewayMulticastDomainRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayMulticastDomainRequest(arg0 *ec2.DeleteTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DeleteTransitGatewayMulticastDomainOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayMulticastDomainOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayMulticastDomainRequest indicates an expected call of DeleteTransitGatewayMulticastDomainRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayMulticastDomainRequest), arg0) -} - -// DeleteTransitGatewayMulticastDomainWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayMulticastDomainWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayMulticastDomainWithContext indicates an expected call of DeleteTransitGatewayMulticastDomainWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayMulticastDomainWithContext(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, "DeleteTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayMulticastDomainWithContext), varargs...) -} - -// DeleteTransitGatewayPeeringAttachment mocks base method. -func (m *MockEC2) DeleteTransitGatewayPeeringAttachment(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachment", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPeeringAttachment indicates an expected call of DeleteTransitGatewayPeeringAttachment. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPeeringAttachment), arg0) -} - -// DeleteTransitGatewayPeeringAttachmentRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayPeeringAttachmentRequest(arg0 *ec2.DeleteTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayPeeringAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayPeeringAttachmentRequest indicates an expected call of DeleteTransitGatewayPeeringAttachmentRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPeeringAttachmentRequest), arg0) -} - -// DeleteTransitGatewayPeeringAttachmentWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayPeeringAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPeeringAttachmentWithContext indicates an expected call of DeleteTransitGatewayPeeringAttachmentWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPeeringAttachmentWithContext(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, "DeleteTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPeeringAttachmentWithContext), varargs...) -} - -// DeleteTransitGatewayPolicyTable mocks base method. -func (m *MockEC2) DeleteTransitGatewayPolicyTable(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTable", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPolicyTable indicates an expected call of DeleteTransitGatewayPolicyTable. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPolicyTable), arg0) -} - -// DeleteTransitGatewayPolicyTableRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayPolicyTableRequest(arg0 *ec2.DeleteTransitGatewayPolicyTableInput) (*request.Request, *ec2.DeleteTransitGatewayPolicyTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPolicyTableOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayPolicyTableRequest indicates an expected call of DeleteTransitGatewayPolicyTableRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPolicyTableRequest), arg0) -} - -// DeleteTransitGatewayPolicyTableWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayPolicyTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPolicyTableWithContext indicates an expected call of DeleteTransitGatewayPolicyTableWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPolicyTableWithContext(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, "DeleteTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPolicyTableWithContext), varargs...) -} - -// DeleteTransitGatewayPrefixListReference mocks base method. -func (m *MockEC2) DeleteTransitGatewayPrefixListReference(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReference", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPrefixListReference indicates an expected call of DeleteTransitGatewayPrefixListReference. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPrefixListReference), arg0) -} - -// DeleteTransitGatewayPrefixListReferenceRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayPrefixListReferenceRequest(arg0 *ec2.DeleteTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.DeleteTransitGatewayPrefixListReferenceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayPrefixListReferenceRequest indicates an expected call of DeleteTransitGatewayPrefixListReferenceRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPrefixListReferenceRequest), arg0) -} - -// DeleteTransitGatewayPrefixListReferenceWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayPrefixListReferenceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayPrefixListReferenceWithContext indicates an expected call of DeleteTransitGatewayPrefixListReferenceWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayPrefixListReferenceWithContext(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, "DeleteTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayPrefixListReferenceWithContext), varargs...) -} - -// DeleteTransitGatewayRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayRequest(arg0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayRequest indicates an expected call of DeleteTransitGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRequest), arg0) -} - -// DeleteTransitGatewayRoute mocks base method. -func (m *MockEC2) DeleteTransitGatewayRoute(arg0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRoute indicates an expected call of DeleteTransitGatewayRoute. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRoute), arg0) -} - -// DeleteTransitGatewayRouteRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteRequest(arg0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteRequest indicates an expected call of DeleteTransitGatewayRouteRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteRequest), arg0) -} - -// DeleteTransitGatewayRouteTable mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTable(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTable indicates an expected call of DeleteTransitGatewayRouteTable. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTable), arg0) -} - -// DeleteTransitGatewayRouteTableAnnouncement mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTableAnnouncement(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncement", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTableAnnouncement indicates an expected call of DeleteTransitGatewayRouteTableAnnouncement. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTableAnnouncement(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncement", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTableAnnouncement), arg0) -} - -// DeleteTransitGatewayRouteTableAnnouncementRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTableAnnouncementRequest indicates an expected call of DeleteTransitGatewayRouteTableAnnouncementRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTableAnnouncementRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableAnnouncementRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTableAnnouncementRequest), arg0) -} - -// DeleteTransitGatewayRouteTableAnnouncementWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTableAnnouncementWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableAnnouncementInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableAnnouncementWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableAnnouncementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTableAnnouncementWithContext indicates an expected call of DeleteTransitGatewayRouteTableAnnouncementWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTableAnnouncementWithContext(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, "DeleteTransitGatewayRouteTableAnnouncementWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTableAnnouncementWithContext), varargs...) -} - -// DeleteTransitGatewayRouteTableRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTableRequest(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTableRequest indicates an expected call of DeleteTransitGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTableRequest), arg0) -} - -// DeleteTransitGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteTableWithContext indicates an expected call of DeleteTransitGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteTableWithContext(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, "DeleteTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteTableWithContext), varargs...) -} - -// DeleteTransitGatewayRouteWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayRouteWithContext indicates an expected call of DeleteTransitGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayRouteWithContext(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, "DeleteTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayRouteWithContext), varargs...) -} - -// DeleteTransitGatewayVpcAttachment mocks base method. -func (m *MockEC2) DeleteTransitGatewayVpcAttachment(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachment", arg0) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayVpcAttachment indicates an expected call of DeleteTransitGatewayVpcAttachment. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayVpcAttachment), arg0) -} - -// DeleteTransitGatewayVpcAttachmentRequest mocks base method. -func (m *MockEC2) DeleteTransitGatewayVpcAttachmentRequest(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) - return ret0, ret1 -} - -// DeleteTransitGatewayVpcAttachmentRequest indicates an expected call of DeleteTransitGatewayVpcAttachmentRequest. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0) -} - -// DeleteTransitGatewayVpcAttachmentWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayVpcAttachmentWithContext indicates an expected call of DeleteTransitGatewayVpcAttachmentWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayVpcAttachmentWithContext(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, "DeleteTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayVpcAttachmentWithContext), varargs...) -} - -// DeleteTransitGatewayWithContext mocks base method. -func (m *MockEC2) DeleteTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteTransitGatewayInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTransitGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteTransitGatewayWithContext indicates an expected call of DeleteTransitGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteTransitGatewayWithContext(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, "DeleteTransitGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteTransitGatewayWithContext), varargs...) -} - -// DeleteVerifiedAccessEndpoint mocks base method. -func (m *MockEC2) DeleteVerifiedAccessEndpoint(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*ec2.DeleteVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpoint", arg0) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessEndpoint indicates an expected call of DeleteVerifiedAccessEndpoint. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessEndpoint), arg0) -} - -// DeleteVerifiedAccessEndpointRequest mocks base method. -func (m *MockEC2) DeleteVerifiedAccessEndpointRequest(arg0 *ec2.DeleteVerifiedAccessEndpointInput) (*request.Request, *ec2.DeleteVerifiedAccessEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessEndpointOutput) - return ret0, ret1 -} - -// DeleteVerifiedAccessEndpointRequest indicates an expected call of DeleteVerifiedAccessEndpointRequest. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessEndpointRequest), arg0) -} - -// DeleteVerifiedAccessEndpointWithContext mocks base method. -func (m *MockEC2) DeleteVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVerifiedAccessEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessEndpointWithContext indicates an expected call of DeleteVerifiedAccessEndpointWithContext. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessEndpointWithContext(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, "DeleteVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessEndpointWithContext), varargs...) -} - -// DeleteVerifiedAccessGroup mocks base method. -func (m *MockEC2) DeleteVerifiedAccessGroup(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*ec2.DeleteVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroup", arg0) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessGroup indicates an expected call of DeleteVerifiedAccessGroup. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroup", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessGroup), arg0) -} - -// DeleteVerifiedAccessGroupRequest mocks base method. -func (m *MockEC2) DeleteVerifiedAccessGroupRequest(arg0 *ec2.DeleteVerifiedAccessGroupInput) (*request.Request, *ec2.DeleteVerifiedAccessGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessGroupOutput) - return ret0, ret1 -} - -// DeleteVerifiedAccessGroupRequest indicates an expected call of DeleteVerifiedAccessGroupRequest. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessGroupRequest), arg0) -} - -// DeleteVerifiedAccessGroupWithContext mocks base method. -func (m *MockEC2) DeleteVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVerifiedAccessGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessGroupWithContext indicates an expected call of DeleteVerifiedAccessGroupWithContext. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessGroupWithContext(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, "DeleteVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessGroupWithContext), varargs...) -} - -// DeleteVerifiedAccessInstance mocks base method. -func (m *MockEC2) DeleteVerifiedAccessInstance(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*ec2.DeleteVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstance", arg0) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessInstance indicates an expected call of DeleteVerifiedAccessInstance. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstance", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessInstance), arg0) -} - -// DeleteVerifiedAccessInstanceRequest mocks base method. -func (m *MockEC2) DeleteVerifiedAccessInstanceRequest(arg0 *ec2.DeleteVerifiedAccessInstanceInput) (*request.Request, *ec2.DeleteVerifiedAccessInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessInstanceOutput) - return ret0, ret1 -} - -// DeleteVerifiedAccessInstanceRequest indicates an expected call of DeleteVerifiedAccessInstanceRequest. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessInstanceRequest), arg0) -} - -// DeleteVerifiedAccessInstanceWithContext mocks base method. -func (m *MockEC2) DeleteVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVerifiedAccessInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessInstanceWithContext indicates an expected call of DeleteVerifiedAccessInstanceWithContext. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessInstanceWithContext(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, "DeleteVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessInstanceWithContext), varargs...) -} - -// DeleteVerifiedAccessTrustProvider mocks base method. -func (m *MockEC2) DeleteVerifiedAccessTrustProvider(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProvider", arg0) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessTrustProvider indicates an expected call of DeleteVerifiedAccessTrustProvider. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessTrustProvider), arg0) -} - -// DeleteVerifiedAccessTrustProviderRequest mocks base method. -func (m *MockEC2) DeleteVerifiedAccessTrustProviderRequest(arg0 *ec2.DeleteVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DeleteVerifiedAccessTrustProviderOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVerifiedAccessTrustProviderOutput) - return ret0, ret1 -} - -// DeleteVerifiedAccessTrustProviderRequest indicates an expected call of DeleteVerifiedAccessTrustProviderRequest. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessTrustProviderRequest), arg0) -} - -// DeleteVerifiedAccessTrustProviderWithContext mocks base method. -func (m *MockEC2) DeleteVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DeleteVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DeleteVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVerifiedAccessTrustProviderWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVerifiedAccessTrustProviderWithContext indicates an expected call of DeleteVerifiedAccessTrustProviderWithContext. -func (mr *MockEC2MockRecorder) DeleteVerifiedAccessTrustProviderWithContext(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, "DeleteVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVerifiedAccessTrustProviderWithContext), varargs...) -} - -// DeleteVolume mocks base method. -func (m *MockEC2) DeleteVolume(arg0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVolume", arg0) - ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVolume indicates an expected call of DeleteVolume. -func (mr *MockEC2MockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2)(nil).DeleteVolume), arg0) -} - -// DeleteVolumeRequest mocks base method. -func (m *MockEC2) DeleteVolumeRequest(arg0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVolumeOutput) - return ret0, ret1 -} - -// DeleteVolumeRequest indicates an expected call of DeleteVolumeRequest. -func (mr *MockEC2MockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVolumeRequest), arg0) -} - -// DeleteVolumeWithContext mocks base method. -func (m *MockEC2) DeleteVolumeWithContext(arg0 context.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVolumeWithContext indicates an expected call of DeleteVolumeWithContext. -func (mr *MockEC2MockRecorder) DeleteVolumeWithContext(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, "DeleteVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVolumeWithContext), varargs...) -} - -// DeleteVpc mocks base method. -func (m *MockEC2) DeleteVpc(arg0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpc", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpc indicates an expected call of DeleteVpc. -func (mr *MockEC2MockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2)(nil).DeleteVpc), arg0) -} - -// DeleteVpcEndpointConnectionNotifications mocks base method. -func (m *MockEC2) DeleteVpcEndpointConnectionNotifications(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotifications", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpointConnectionNotifications indicates an expected call of DeleteVpcEndpointConnectionNotifications. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointConnectionNotifications), arg0) -} - -// DeleteVpcEndpointConnectionNotificationsRequest mocks base method. -func (m *MockEC2) DeleteVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) - return ret0, ret1 -} - -// DeleteVpcEndpointConnectionNotificationsRequest indicates an expected call of DeleteVpcEndpointConnectionNotificationsRequest. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0) -} - -// DeleteVpcEndpointConnectionNotificationsWithContext mocks base method. -func (m *MockEC2) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpointConnectionNotificationsWithContext indicates an expected call of DeleteVpcEndpointConnectionNotificationsWithContext. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointConnectionNotificationsWithContext(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, "DeleteVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointConnectionNotificationsWithContext), varargs...) -} - -// DeleteVpcEndpointServiceConfigurations mocks base method. -func (m *MockEC2) DeleteVpcEndpointServiceConfigurations(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurations", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpointServiceConfigurations indicates an expected call of DeleteVpcEndpointServiceConfigurations. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointServiceConfigurations), arg0) -} - -// DeleteVpcEndpointServiceConfigurationsRequest mocks base method. -func (m *MockEC2) DeleteVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) - return ret0, ret1 -} - -// DeleteVpcEndpointServiceConfigurationsRequest indicates an expected call of DeleteVpcEndpointServiceConfigurationsRequest. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0) -} - -// DeleteVpcEndpointServiceConfigurationsWithContext mocks base method. -func (m *MockEC2) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpointServiceConfigurationsWithContext indicates an expected call of DeleteVpcEndpointServiceConfigurationsWithContext. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointServiceConfigurationsWithContext(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, "DeleteVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointServiceConfigurationsWithContext), varargs...) -} - -// DeleteVpcEndpoints mocks base method. -func (m *MockEC2) DeleteVpcEndpoints(arg0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpoints", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints. -func (mr *MockEC2MockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpoints), arg0) -} - -// DeleteVpcEndpointsRequest mocks base method. -func (m *MockEC2) DeleteVpcEndpointsRequest(arg0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcEndpointsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpcEndpointsOutput) - return ret0, ret1 -} - -// DeleteVpcEndpointsRequest indicates an expected call of DeleteVpcEndpointsRequest. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointsRequest), arg0) -} - -// DeleteVpcEndpointsWithContext mocks base method. -func (m *MockEC2) DeleteVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpcEndpointsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcEndpointsWithContext indicates an expected call of DeleteVpcEndpointsWithContext. -func (mr *MockEC2MockRecorder) DeleteVpcEndpointsWithContext(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, "DeleteVpcEndpointsWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpcEndpointsWithContext), varargs...) -} - -// DeleteVpcPeeringConnection mocks base method. -func (m *MockEC2) DeleteVpcPeeringConnection(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection. -func (mr *MockEC2MockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2)(nil).DeleteVpcPeeringConnection), arg0) -} - -// DeleteVpcPeeringConnectionRequest mocks base method. -func (m *MockEC2) DeleteVpcPeeringConnectionRequest(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpcPeeringConnectionOutput) - return ret0, ret1 -} - -// DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest. -func (mr *MockEC2MockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpcPeeringConnectionRequest), arg0) -} - -// DeleteVpcPeeringConnectionWithContext mocks base method. -func (m *MockEC2) DeleteVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcPeeringConnectionWithContext indicates an expected call of DeleteVpcPeeringConnectionWithContext. -func (mr *MockEC2MockRecorder) DeleteVpcPeeringConnectionWithContext(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, "DeleteVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpcPeeringConnectionWithContext), varargs...) -} - -// DeleteVpcRequest mocks base method. -func (m *MockEC2) DeleteVpcRequest(arg0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpcOutput) - return ret0, ret1 -} - -// DeleteVpcRequest indicates an expected call of DeleteVpcRequest. -func (mr *MockEC2MockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpcRequest), arg0) -} - -// DeleteVpcWithContext mocks base method. -func (m *MockEC2) DeleteVpcWithContext(arg0 context.Context, arg1 *ec2.DeleteVpcInput, arg2 ...request.Option) (*ec2.DeleteVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpcWithContext indicates an expected call of DeleteVpcWithContext. -func (mr *MockEC2MockRecorder) DeleteVpcWithContext(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, "DeleteVpcWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpcWithContext), varargs...) -} - -// DeleteVpnConnection mocks base method. -func (m *MockEC2) DeleteVpnConnection(arg0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnConnection", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnConnection indicates an expected call of DeleteVpnConnection. -func (mr *MockEC2MockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnection), arg0) -} - -// DeleteVpnConnectionRequest mocks base method. -func (m *MockEC2) DeleteVpnConnectionRequest(arg0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpnConnectionOutput) - return ret0, ret1 -} - -// DeleteVpnConnectionRequest indicates an expected call of DeleteVpnConnectionRequest. -func (mr *MockEC2MockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnectionRequest), arg0) -} - -// DeleteVpnConnectionRoute mocks base method. -func (m *MockEC2) DeleteVpnConnectionRoute(arg0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnConnectionRoute", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnConnectionRoute indicates an expected call of DeleteVpnConnectionRoute. -func (mr *MockEC2MockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnectionRoute), arg0) -} - -// DeleteVpnConnectionRouteRequest mocks base method. -func (m *MockEC2) DeleteVpnConnectionRouteRequest(arg0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpnConnectionRouteOutput) - return ret0, ret1 -} - -// DeleteVpnConnectionRouteRequest indicates an expected call of DeleteVpnConnectionRouteRequest. -func (mr *MockEC2MockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnectionRouteRequest), arg0) -} - -// DeleteVpnConnectionRouteWithContext mocks base method. -func (m *MockEC2) DeleteVpnConnectionRouteWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnConnectionRouteWithContext indicates an expected call of DeleteVpnConnectionRouteWithContext. -func (mr *MockEC2MockRecorder) DeleteVpnConnectionRouteWithContext(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, "DeleteVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnectionRouteWithContext), varargs...) -} - -// DeleteVpnConnectionWithContext mocks base method. -func (m *MockEC2) DeleteVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpnConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnConnectionWithContext indicates an expected call of DeleteVpnConnectionWithContext. -func (mr *MockEC2MockRecorder) DeleteVpnConnectionWithContext(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, "DeleteVpnConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpnConnectionWithContext), varargs...) -} - -// DeleteVpnGateway mocks base method. -func (m *MockEC2) DeleteVpnGateway(arg0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnGateway", arg0) - ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnGateway indicates an expected call of DeleteVpnGateway. -func (mr *MockEC2MockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2)(nil).DeleteVpnGateway), arg0) -} - -// DeleteVpnGatewayRequest mocks base method. -func (m *MockEC2) DeleteVpnGatewayRequest(arg0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteVpnGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeleteVpnGatewayOutput) - return ret0, ret1 -} - -// DeleteVpnGatewayRequest indicates an expected call of DeleteVpnGatewayRequest. -func (mr *MockEC2MockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DeleteVpnGatewayRequest), arg0) -} - -// DeleteVpnGatewayWithContext mocks base method. -func (m *MockEC2) DeleteVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DeleteVpnGatewayInput, arg2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteVpnGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteVpnGatewayWithContext indicates an expected call of DeleteVpnGatewayWithContext. -func (mr *MockEC2MockRecorder) DeleteVpnGatewayWithContext(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, "DeleteVpnGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DeleteVpnGatewayWithContext), varargs...) -} - -// DeprovisionByoipCidr mocks base method. -func (m *MockEC2) DeprovisionByoipCidr(arg0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionByoipCidr", arg0) - ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionByoipCidr indicates an expected call of DeprovisionByoipCidr. -func (mr *MockEC2MockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2)(nil).DeprovisionByoipCidr), arg0) -} - -// DeprovisionByoipCidrRequest mocks base method. -func (m *MockEC2) DeprovisionByoipCidrRequest(arg0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionByoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeprovisionByoipCidrOutput) - return ret0, ret1 -} - -// DeprovisionByoipCidrRequest indicates an expected call of DeprovisionByoipCidrRequest. -func (mr *MockEC2MockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).DeprovisionByoipCidrRequest), arg0) -} - -// DeprovisionByoipCidrWithContext mocks base method. -func (m *MockEC2) DeprovisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionByoipCidrInput, arg2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeprovisionByoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionByoipCidrWithContext indicates an expected call of DeprovisionByoipCidrWithContext. -func (mr *MockEC2MockRecorder) DeprovisionByoipCidrWithContext(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, "DeprovisionByoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).DeprovisionByoipCidrWithContext), varargs...) -} - -// DeprovisionIpamByoasn mocks base method. -func (m *MockEC2) DeprovisionIpamByoasn(arg0 *ec2.DeprovisionIpamByoasnInput) (*ec2.DeprovisionIpamByoasnOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionIpamByoasn", arg0) - ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionIpamByoasn indicates an expected call of DeprovisionIpamByoasn. -func (mr *MockEC2MockRecorder) DeprovisionIpamByoasn(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasn", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamByoasn), arg0) -} - -// DeprovisionIpamByoasnRequest mocks base method. -func (m *MockEC2) DeprovisionIpamByoasnRequest(arg0 *ec2.DeprovisionIpamByoasnInput) (*request.Request, *ec2.DeprovisionIpamByoasnOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionIpamByoasnRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeprovisionIpamByoasnOutput) - return ret0, ret1 -} - -// DeprovisionIpamByoasnRequest indicates an expected call of DeprovisionIpamByoasnRequest. -func (mr *MockEC2MockRecorder) DeprovisionIpamByoasnRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamByoasnRequest", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamByoasnRequest), arg0) -} - -// DeprovisionIpamByoasnWithContext mocks base method. -func (m *MockEC2) DeprovisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamByoasnInput, arg2 ...request.Option) (*ec2.DeprovisionIpamByoasnOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeprovisionIpamByoasnWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeprovisionIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionIpamByoasnWithContext indicates an expected call of DeprovisionIpamByoasnWithContext. -func (mr *MockEC2MockRecorder) DeprovisionIpamByoasnWithContext(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, "DeprovisionIpamByoasnWithContext", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamByoasnWithContext), varargs...) -} - -// DeprovisionIpamPoolCidr mocks base method. -func (m *MockEC2) DeprovisionIpamPoolCidr(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*ec2.DeprovisionIpamPoolCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidr", arg0) - ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionIpamPoolCidr indicates an expected call of DeprovisionIpamPoolCidr. -func (mr *MockEC2MockRecorder) DeprovisionIpamPoolCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidr", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamPoolCidr), arg0) -} - -// DeprovisionIpamPoolCidrRequest mocks base method. -func (m *MockEC2) DeprovisionIpamPoolCidrRequest(arg0 *ec2.DeprovisionIpamPoolCidrInput) (*request.Request, *ec2.DeprovisionIpamPoolCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeprovisionIpamPoolCidrOutput) - return ret0, ret1 -} - -// DeprovisionIpamPoolCidrRequest indicates an expected call of DeprovisionIpamPoolCidrRequest. -func (mr *MockEC2MockRecorder) DeprovisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamPoolCidrRequest), arg0) -} - -// DeprovisionIpamPoolCidrWithContext mocks base method. -func (m *MockEC2) DeprovisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionIpamPoolCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeprovisionIpamPoolCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeprovisionIpamPoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionIpamPoolCidrWithContext indicates an expected call of DeprovisionIpamPoolCidrWithContext. -func (mr *MockEC2MockRecorder) DeprovisionIpamPoolCidrWithContext(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, "DeprovisionIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2)(nil).DeprovisionIpamPoolCidrWithContext), varargs...) -} - -// DeprovisionPublicIpv4PoolCidr mocks base method. -func (m *MockEC2) DeprovisionPublicIpv4PoolCidr(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidr", arg0) - ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionPublicIpv4PoolCidr indicates an expected call of DeprovisionPublicIpv4PoolCidr. -func (mr *MockEC2MockRecorder) DeprovisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2)(nil).DeprovisionPublicIpv4PoolCidr), arg0) -} - -// DeprovisionPublicIpv4PoolCidrRequest mocks base method. -func (m *MockEC2) DeprovisionPublicIpv4PoolCidrRequest(arg0 *ec2.DeprovisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.DeprovisionPublicIpv4PoolCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeprovisionPublicIpv4PoolCidrOutput) - return ret0, ret1 -} - -// DeprovisionPublicIpv4PoolCidrRequest indicates an expected call of DeprovisionPublicIpv4PoolCidrRequest. -func (mr *MockEC2MockRecorder) DeprovisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2)(nil).DeprovisionPublicIpv4PoolCidrRequest), arg0) -} - -// DeprovisionPublicIpv4PoolCidrWithContext mocks base method. -func (m *MockEC2) DeprovisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.DeprovisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.DeprovisionPublicIpv4PoolCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeprovisionPublicIpv4PoolCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeprovisionPublicIpv4PoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeprovisionPublicIpv4PoolCidrWithContext indicates an expected call of DeprovisionPublicIpv4PoolCidrWithContext. -func (mr *MockEC2MockRecorder) DeprovisionPublicIpv4PoolCidrWithContext(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, "DeprovisionPublicIpv4PoolCidrWithContext", reflect.TypeOf((*MockEC2)(nil).DeprovisionPublicIpv4PoolCidrWithContext), varargs...) -} - -// DeregisterImage mocks base method. -func (m *MockEC2) DeregisterImage(arg0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterImage", arg0) - ret0, _ := ret[0].(*ec2.DeregisterImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterImage indicates an expected call of DeregisterImage. -func (mr *MockEC2MockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2)(nil).DeregisterImage), arg0) -} - -// DeregisterImageRequest mocks base method. -func (m *MockEC2) DeregisterImageRequest(arg0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeregisterImageOutput) - return ret0, ret1 -} - -// DeregisterImageRequest indicates an expected call of DeregisterImageRequest. -func (mr *MockEC2MockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2)(nil).DeregisterImageRequest), arg0) -} - -// DeregisterImageWithContext mocks base method. -func (m *MockEC2) DeregisterImageWithContext(arg0 context.Context, arg1 *ec2.DeregisterImageInput, arg2 ...request.Option) (*ec2.DeregisterImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeregisterImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterImageWithContext indicates an expected call of DeregisterImageWithContext. -func (mr *MockEC2MockRecorder) DeregisterImageWithContext(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, "DeregisterImageWithContext", reflect.TypeOf((*MockEC2)(nil).DeregisterImageWithContext), varargs...) -} - -// DeregisterInstanceEventNotificationAttributes mocks base method. -func (m *MockEC2) DeregisterInstanceEventNotificationAttributes(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributes", arg0) - ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterInstanceEventNotificationAttributes indicates an expected call of DeregisterInstanceEventNotificationAttributes. -func (mr *MockEC2MockRecorder) DeregisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2)(nil).DeregisterInstanceEventNotificationAttributes), arg0) -} - -// DeregisterInstanceEventNotificationAttributesRequest mocks base method. -func (m *MockEC2) DeregisterInstanceEventNotificationAttributesRequest(arg0 *ec2.DeregisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DeregisterInstanceEventNotificationAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) - return ret0, ret1 -} - -// DeregisterInstanceEventNotificationAttributesRequest indicates an expected call of DeregisterInstanceEventNotificationAttributesRequest. -func (mr *MockEC2MockRecorder) DeregisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2)(nil).DeregisterInstanceEventNotificationAttributesRequest), arg0) -} - -// DeregisterInstanceEventNotificationAttributesWithContext mocks base method. -func (m *MockEC2) DeregisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DeregisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DeregisterInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterInstanceEventNotificationAttributesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeregisterInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterInstanceEventNotificationAttributesWithContext indicates an expected call of DeregisterInstanceEventNotificationAttributesWithContext. -func (mr *MockEC2MockRecorder) DeregisterInstanceEventNotificationAttributesWithContext(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, "DeregisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2)(nil).DeregisterInstanceEventNotificationAttributesWithContext), varargs...) -} - -// DeregisterTransitGatewayMulticastGroupMembers mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupMembers(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembers", arg0) - ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupMembers indicates an expected call of DeregisterTransitGatewayMulticastGroupMembers. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupMembers), arg0) -} - -// DeregisterTransitGatewayMulticastGroupMembersRequest mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersRequest. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupMembersRequest), arg0) -} - -// DeregisterTransitGatewayMulticastGroupMembersWithContext mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupMembersWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupMembersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupMembersWithContext. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupMembersWithContext(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, "DeregisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupMembersWithContext), varargs...) -} - -// DeregisterTransitGatewayMulticastGroupSources mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupSources(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSources", arg0) - ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupSources indicates an expected call of DeregisterTransitGatewayMulticastGroupSources. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupSources), arg0) -} - -// DeregisterTransitGatewayMulticastGroupSourcesRequest mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesRequest. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupSourcesRequest), arg0) -} - -// DeregisterTransitGatewayMulticastGroupSourcesWithContext mocks base method. -func (m *MockEC2) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.DeregisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DeregisterTransitGatewayMulticastGroupSourcesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeregisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of DeregisterTransitGatewayMulticastGroupSourcesWithContext. -func (mr *MockEC2MockRecorder) DeregisterTransitGatewayMulticastGroupSourcesWithContext(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, "DeregisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2)(nil).DeregisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) -} - -// DescribeAccountAttributes mocks base method. -func (m *MockEC2) DescribeAccountAttributes(arg0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0) - ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes. -func (mr *MockEC2MockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2)(nil).DescribeAccountAttributes), arg0) -} - -// DescribeAccountAttributesRequest mocks base method. -func (m *MockEC2) DescribeAccountAttributesRequest(arg0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAccountAttributesOutput) - return ret0, ret1 -} - -// DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest. -func (mr *MockEC2MockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAccountAttributesRequest), arg0) -} - -// DescribeAccountAttributesWithContext mocks base method. -func (m *MockEC2) DescribeAccountAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeAccountAttributesInput, arg2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext. -func (mr *MockEC2MockRecorder) DescribeAccountAttributesWithContext(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, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAccountAttributesWithContext), varargs...) -} - -// DescribeAddressTransfers mocks base method. -func (m *MockEC2) DescribeAddressTransfers(arg0 *ec2.DescribeAddressTransfersInput) (*ec2.DescribeAddressTransfersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressTransfers", arg0) - ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAddressTransfers indicates an expected call of DescribeAddressTransfers. -func (mr *MockEC2MockRecorder) DescribeAddressTransfers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfers", reflect.TypeOf((*MockEC2)(nil).DescribeAddressTransfers), arg0) -} - -// DescribeAddressTransfersPages mocks base method. -func (m *MockEC2) DescribeAddressTransfersPages(arg0 *ec2.DescribeAddressTransfersInput, arg1 func(*ec2.DescribeAddressTransfersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressTransfersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAddressTransfersPages indicates an expected call of DescribeAddressTransfersPages. -func (mr *MockEC2MockRecorder) DescribeAddressTransfersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersPages", reflect.TypeOf((*MockEC2)(nil).DescribeAddressTransfersPages), arg0, arg1) -} - -// DescribeAddressTransfersPagesWithContext mocks base method. -func (m *MockEC2) DescribeAddressTransfersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 func(*ec2.DescribeAddressTransfersOutput, 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, "DescribeAddressTransfersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAddressTransfersPagesWithContext indicates an expected call of DescribeAddressTransfersPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeAddressTransfersPagesWithContext(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, "DescribeAddressTransfersPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAddressTransfersPagesWithContext), varargs...) -} - -// DescribeAddressTransfersRequest mocks base method. -func (m *MockEC2) DescribeAddressTransfersRequest(arg0 *ec2.DescribeAddressTransfersInput) (*request.Request, *ec2.DescribeAddressTransfersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressTransfersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAddressTransfersOutput) - return ret0, ret1 -} - -// DescribeAddressTransfersRequest indicates an expected call of DescribeAddressTransfersRequest. -func (mr *MockEC2MockRecorder) DescribeAddressTransfersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressTransfersRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAddressTransfersRequest), arg0) -} - -// DescribeAddressTransfersWithContext mocks base method. -func (m *MockEC2) DescribeAddressTransfersWithContext(arg0 context.Context, arg1 *ec2.DescribeAddressTransfersInput, arg2 ...request.Option) (*ec2.DescribeAddressTransfersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAddressTransfersWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAddressTransfersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAddressTransfersWithContext indicates an expected call of DescribeAddressTransfersWithContext. -func (mr *MockEC2MockRecorder) DescribeAddressTransfersWithContext(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, "DescribeAddressTransfersWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAddressTransfersWithContext), varargs...) -} - -// DescribeAddresses mocks base method. -func (m *MockEC2) DescribeAddresses(arg0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddresses", arg0) - ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAddresses indicates an expected call of DescribeAddresses. -func (mr *MockEC2MockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2)(nil).DescribeAddresses), arg0) -} - -// DescribeAddressesAttribute mocks base method. -func (m *MockEC2) DescribeAddressesAttribute(arg0 *ec2.DescribeAddressesAttributeInput) (*ec2.DescribeAddressesAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressesAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeAddressesAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAddressesAttribute indicates an expected call of DescribeAddressesAttribute. -func (mr *MockEC2MockRecorder) DescribeAddressesAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeAddressesAttribute), arg0) -} - -// DescribeAddressesAttributePages mocks base method. -func (m *MockEC2) DescribeAddressesAttributePages(arg0 *ec2.DescribeAddressesAttributeInput, arg1 func(*ec2.DescribeAddressesAttributeOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressesAttributePages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAddressesAttributePages indicates an expected call of DescribeAddressesAttributePages. -func (mr *MockEC2MockRecorder) DescribeAddressesAttributePages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributePages", reflect.TypeOf((*MockEC2)(nil).DescribeAddressesAttributePages), arg0, arg1) -} - -// DescribeAddressesAttributePagesWithContext mocks base method. -func (m *MockEC2) DescribeAddressesAttributePagesWithContext(arg0 context.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, "DescribeAddressesAttributePagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAddressesAttributePagesWithContext indicates an expected call of DescribeAddressesAttributePagesWithContext. -func (mr *MockEC2MockRecorder) DescribeAddressesAttributePagesWithContext(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, "DescribeAddressesAttributePagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAddressesAttributePagesWithContext), varargs...) -} - -// DescribeAddressesAttributeRequest mocks base method. -func (m *MockEC2) DescribeAddressesAttributeRequest(arg0 *ec2.DescribeAddressesAttributeInput) (*request.Request, *ec2.DescribeAddressesAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAddressesAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAddressesAttributeOutput) - return ret0, ret1 -} - -// DescribeAddressesAttributeRequest indicates an expected call of DescribeAddressesAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeAddressesAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAddressesAttributeRequest), arg0) -} - -// DescribeAddressesAttributeWithContext mocks base method. -func (m *MockEC2) DescribeAddressesAttributeWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeAddressesAttributeWithContext), varargs...) -} - -// DescribeAddressesRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAddressesRequest), arg0) -} - -// DescribeAddressesWithContext mocks base method. -func (m *MockEC2) DescribeAddressesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeAddressesWithContext), varargs...) -} - -// DescribeAggregateIdFormat mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2)(nil).DescribeAggregateIdFormat), arg0) -} - -// DescribeAggregateIdFormatRequest mocks base method. -func (m *MockEC2) DescribeAggregateIdFormatRequest(arg0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAggregateIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAggregateIdFormatOutput) - return ret0, ret1 -} - -// DescribeAggregateIdFormatRequest indicates an expected call of DescribeAggregateIdFormatRequest. -func (mr *MockEC2MockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAggregateIdFormatRequest), arg0) -} - -// DescribeAggregateIdFormatWithContext mocks base method. -func (m *MockEC2) DescribeAggregateIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeAggregateIdFormatInput, arg2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAggregateIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAggregateIdFormatWithContext indicates an expected call of DescribeAggregateIdFormatWithContext. -func (mr *MockEC2MockRecorder) DescribeAggregateIdFormatWithContext(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, "DescribeAggregateIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAggregateIdFormatWithContext), varargs...) -} - -// DescribeAvailabilityZones mocks base method. -func (m *MockEC2) DescribeAvailabilityZones(arg0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAvailabilityZones", arg0) - ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones. -func (mr *MockEC2MockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2)(nil).DescribeAvailabilityZones), arg0) -} - -// DescribeAvailabilityZonesRequest mocks base method. -func (m *MockEC2) DescribeAvailabilityZonesRequest(arg0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAvailabilityZonesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAvailabilityZonesOutput) - return ret0, ret1 -} - -// DescribeAvailabilityZonesRequest indicates an expected call of DescribeAvailabilityZonesRequest. -func (mr *MockEC2MockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAvailabilityZonesRequest), arg0) -} - -// DescribeAvailabilityZonesWithContext mocks base method. -func (m *MockEC2) DescribeAvailabilityZonesWithContext(arg0 context.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext. -func (mr *MockEC2MockRecorder) DescribeAvailabilityZonesWithContext(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, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAvailabilityZonesWithContext), varargs...) -} - -// DescribeAwsNetworkPerformanceMetricSubscriptions mocks base method. -func (m *MockEC2) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptions", arg0) - ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAwsNetworkPerformanceMetricSubscriptions indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptions. -func (mr *MockEC2MockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptions", reflect.TypeOf((*MockEC2)(nil).DescribeAwsNetworkPerformanceMetricSubscriptions), arg0) -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsPages mocks base method. -func (m *MockEC2) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg1 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsPages indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsPages. -func (mr *MockEC2MockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsPages), arg0, arg1) -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 func(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, 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, "DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext(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, "DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsPagesWithContext), varargs...) -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest mocks base method. -func (m *MockEC2) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput) (*request.Request, *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) - return ret0, ret1 -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsRequest indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsRequest. -func (mr *MockEC2MockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAwsNetworkPerformanceMetricSubscriptionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsRequest), arg0) -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext mocks base method. -func (m *MockEC2) DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsInput, arg2 ...request.Option) (*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeAwsNetworkPerformanceMetricSubscriptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext indicates an expected call of DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext. -func (mr *MockEC2MockRecorder) DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext(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, "DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeAwsNetworkPerformanceMetricSubscriptionsWithContext), varargs...) -} - -// DescribeBundleTasks mocks base method. -func (m *MockEC2) DescribeBundleTasks(arg0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeBundleTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeBundleTasks indicates an expected call of DescribeBundleTasks. -func (mr *MockEC2MockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2)(nil).DescribeBundleTasks), arg0) -} - -// DescribeBundleTasksRequest mocks base method. -func (m *MockEC2) DescribeBundleTasksRequest(arg0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeBundleTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeBundleTasksOutput) - return ret0, ret1 -} - -// DescribeBundleTasksRequest indicates an expected call of DescribeBundleTasksRequest. -func (mr *MockEC2MockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeBundleTasksRequest), arg0) -} - -// DescribeBundleTasksWithContext mocks base method. -func (m *MockEC2) DescribeBundleTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.Option) (*ec2.DescribeBundleTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeBundleTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeBundleTasksWithContext indicates an expected call of DescribeBundleTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeBundleTasksWithContext(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, "DescribeBundleTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeBundleTasksWithContext), varargs...) -} - -// DescribeByoipCidrs mocks base method. -func (m *MockEC2) DescribeByoipCidrs(arg0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeByoipCidrs", arg0) - ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeByoipCidrs indicates an expected call of DescribeByoipCidrs. -func (mr *MockEC2MockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2)(nil).DescribeByoipCidrs), arg0) -} - -// DescribeByoipCidrsPages mocks base method. -func (m *MockEC2) DescribeByoipCidrsPages(arg0 *ec2.DescribeByoipCidrsInput, arg1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeByoipCidrsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeByoipCidrsPages indicates an expected call of DescribeByoipCidrsPages. -func (mr *MockEC2MockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2)(nil).DescribeByoipCidrsPages), arg0, arg1) -} - -// DescribeByoipCidrsPagesWithContext mocks base method. -func (m *MockEC2) DescribeByoipCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 func(*ec2.DescribeByoipCidrsOutput, 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, "DescribeByoipCidrsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeByoipCidrsPagesWithContext indicates an expected call of DescribeByoipCidrsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeByoipCidrsPagesWithContext(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, "DescribeByoipCidrsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeByoipCidrsPagesWithContext), varargs...) -} - -// DescribeByoipCidrsRequest mocks base method. -func (m *MockEC2) DescribeByoipCidrsRequest(arg0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeByoipCidrsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeByoipCidrsOutput) - return ret0, ret1 -} - -// DescribeByoipCidrsRequest indicates an expected call of DescribeByoipCidrsRequest. -func (mr *MockEC2MockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeByoipCidrsRequest), arg0) -} - -// DescribeByoipCidrsWithContext mocks base method. -func (m *MockEC2) DescribeByoipCidrsWithContext(arg0 context.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeByoipCidrsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeByoipCidrsWithContext indicates an expected call of DescribeByoipCidrsWithContext. -func (mr *MockEC2MockRecorder) DescribeByoipCidrsWithContext(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, "DescribeByoipCidrsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeByoipCidrsWithContext), varargs...) -} - -// DescribeCapacityBlockOfferings mocks base method. -func (m *MockEC2) DescribeCapacityBlockOfferings(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*ec2.DescribeCapacityBlockOfferingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferings", arg0) - ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityBlockOfferings indicates an expected call of DescribeCapacityBlockOfferings. -func (mr *MockEC2MockRecorder) DescribeCapacityBlockOfferings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferings", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityBlockOfferings), arg0) -} - -// DescribeCapacityBlockOfferingsPages mocks base method. -func (m *MockEC2) DescribeCapacityBlockOfferingsPages(arg0 *ec2.DescribeCapacityBlockOfferingsInput, arg1 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityBlockOfferingsPages indicates an expected call of DescribeCapacityBlockOfferingsPages. -func (mr *MockEC2MockRecorder) DescribeCapacityBlockOfferingsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsPages", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityBlockOfferingsPages), arg0, arg1) -} - -// DescribeCapacityBlockOfferingsPagesWithContext mocks base method. -func (m *MockEC2) DescribeCapacityBlockOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 func(*ec2.DescribeCapacityBlockOfferingsOutput, bool) bool, arg3 ...request.Option) error { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityBlockOfferingsPagesWithContext indicates an expected call of DescribeCapacityBlockOfferingsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityBlockOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityBlockOfferingsPagesWithContext), varargs...) -} - -// DescribeCapacityBlockOfferingsRequest mocks base method. -func (m *MockEC2) DescribeCapacityBlockOfferingsRequest(arg0 *ec2.DescribeCapacityBlockOfferingsInput) (*request.Request, *ec2.DescribeCapacityBlockOfferingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCapacityBlockOfferingsOutput) - return ret0, ret1 -} - -// DescribeCapacityBlockOfferingsRequest indicates an expected call of DescribeCapacityBlockOfferingsRequest. -func (mr *MockEC2MockRecorder) DescribeCapacityBlockOfferingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityBlockOfferingsRequest), arg0) -} - -// DescribeCapacityBlockOfferingsWithContext mocks base method. -func (m *MockEC2) DescribeCapacityBlockOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityBlockOfferingsInput, arg2 ...request.Option) (*ec2.DescribeCapacityBlockOfferingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCapacityBlockOfferingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCapacityBlockOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityBlockOfferingsWithContext indicates an expected call of DescribeCapacityBlockOfferingsWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityBlockOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityBlockOfferingsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityBlockOfferingsWithContext), varargs...) -} - -// DescribeCapacityReservationFleets mocks base method. -func (m *MockEC2) DescribeCapacityReservationFleets(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*ec2.DescribeCapacityReservationFleetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservationFleets", arg0) - ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityReservationFleets indicates an expected call of DescribeCapacityReservationFleets. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationFleets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleets", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationFleets), arg0) -} - -// DescribeCapacityReservationFleetsPages mocks base method. -func (m *MockEC2) DescribeCapacityReservationFleetsPages(arg0 *ec2.DescribeCapacityReservationFleetsInput, arg1 func(*ec2.DescribeCapacityReservationFleetsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityReservationFleetsPages indicates an expected call of DescribeCapacityReservationFleetsPages. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationFleetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsPages", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationFleetsPages), arg0, arg1) -} - -// DescribeCapacityReservationFleetsPagesWithContext mocks base method. -func (m *MockEC2) DescribeCapacityReservationFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 func(*ec2.DescribeCapacityReservationFleetsOutput, 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, "DescribeCapacityReservationFleetsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityReservationFleetsPagesWithContext indicates an expected call of DescribeCapacityReservationFleetsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationFleetsPagesWithContext(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, "DescribeCapacityReservationFleetsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationFleetsPagesWithContext), varargs...) -} - -// DescribeCapacityReservationFleetsRequest mocks base method. -func (m *MockEC2) DescribeCapacityReservationFleetsRequest(arg0 *ec2.DescribeCapacityReservationFleetsInput) (*request.Request, *ec2.DescribeCapacityReservationFleetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCapacityReservationFleetsOutput) - return ret0, ret1 -} - -// DescribeCapacityReservationFleetsRequest indicates an expected call of DescribeCapacityReservationFleetsRequest. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationFleetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationFleetsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationFleetsRequest), arg0) -} - -// DescribeCapacityReservationFleetsWithContext mocks base method. -func (m *MockEC2) DescribeCapacityReservationFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationFleetsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationFleetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCapacityReservationFleetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCapacityReservationFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityReservationFleetsWithContext indicates an expected call of DescribeCapacityReservationFleetsWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationFleetsWithContext(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, "DescribeCapacityReservationFleetsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationFleetsWithContext), varargs...) -} - -// DescribeCapacityReservations mocks base method. -func (m *MockEC2) DescribeCapacityReservations(arg0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservations", arg0) - ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityReservations indicates an expected call of DescribeCapacityReservations. -func (mr *MockEC2MockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservations), arg0) -} - -// DescribeCapacityReservationsPages mocks base method. -func (m *MockEC2) DescribeCapacityReservationsPages(arg0 *ec2.DescribeCapacityReservationsInput, arg1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityReservationsPages indicates an expected call of DescribeCapacityReservationsPages. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationsPages), arg0, arg1) -} - -// DescribeCapacityReservationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeCapacityReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 func(*ec2.DescribeCapacityReservationsOutput, 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, "DescribeCapacityReservationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCapacityReservationsPagesWithContext indicates an expected call of DescribeCapacityReservationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationsPagesWithContext(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, "DescribeCapacityReservationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationsPagesWithContext), varargs...) -} - -// DescribeCapacityReservationsRequest mocks base method. -func (m *MockEC2) DescribeCapacityReservationsRequest(arg0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCapacityReservationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCapacityReservationsOutput) - return ret0, ret1 -} - -// DescribeCapacityReservationsRequest indicates an expected call of DescribeCapacityReservationsRequest. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationsRequest), arg0) -} - -// DescribeCapacityReservationsWithContext mocks base method. -func (m *MockEC2) DescribeCapacityReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCapacityReservationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCapacityReservationsWithContext indicates an expected call of DescribeCapacityReservationsWithContext. -func (mr *MockEC2MockRecorder) DescribeCapacityReservationsWithContext(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, "DescribeCapacityReservationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCapacityReservationsWithContext), varargs...) -} - -// DescribeCarrierGateways mocks base method. -func (m *MockEC2) DescribeCarrierGateways(arg0 *ec2.DescribeCarrierGatewaysInput) (*ec2.DescribeCarrierGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCarrierGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCarrierGateways indicates an expected call of DescribeCarrierGateways. -func (mr *MockEC2MockRecorder) DescribeCarrierGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGateways", reflect.TypeOf((*MockEC2)(nil).DescribeCarrierGateways), arg0) -} - -// DescribeCarrierGatewaysPages mocks base method. -func (m *MockEC2) DescribeCarrierGatewaysPages(arg0 *ec2.DescribeCarrierGatewaysInput, arg1 func(*ec2.DescribeCarrierGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCarrierGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCarrierGatewaysPages indicates an expected call of DescribeCarrierGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeCarrierGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeCarrierGatewaysPages), arg0, arg1) -} - -// DescribeCarrierGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeCarrierGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 func(*ec2.DescribeCarrierGatewaysOutput, 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, "DescribeCarrierGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCarrierGatewaysPagesWithContext indicates an expected call of DescribeCarrierGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeCarrierGatewaysPagesWithContext(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, "DescribeCarrierGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCarrierGatewaysPagesWithContext), varargs...) -} - -// DescribeCarrierGatewaysRequest mocks base method. -func (m *MockEC2) DescribeCarrierGatewaysRequest(arg0 *ec2.DescribeCarrierGatewaysInput) (*request.Request, *ec2.DescribeCarrierGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCarrierGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCarrierGatewaysOutput) - return ret0, ret1 -} - -// DescribeCarrierGatewaysRequest indicates an expected call of DescribeCarrierGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeCarrierGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCarrierGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCarrierGatewaysRequest), arg0) -} - -// DescribeCarrierGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeCarrierGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCarrierGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCarrierGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCarrierGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCarrierGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCarrierGatewaysWithContext indicates an expected call of DescribeCarrierGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeCarrierGatewaysWithContext(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, "DescribeCarrierGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCarrierGatewaysWithContext), varargs...) -} - -// DescribeClassicLinkInstances mocks base method. -func (m *MockEC2) DescribeClassicLinkInstances(arg0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClassicLinkInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClassicLinkInstances indicates an expected call of DescribeClassicLinkInstances. -func (mr *MockEC2MockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2)(nil).DescribeClassicLinkInstances), arg0) -} - -// DescribeClassicLinkInstancesPages mocks base method. -func (m *MockEC2) DescribeClassicLinkInstancesPages(arg0 *ec2.DescribeClassicLinkInstancesInput, arg1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClassicLinkInstancesPages indicates an expected call of DescribeClassicLinkInstancesPages. -func (mr *MockEC2MockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2)(nil).DescribeClassicLinkInstancesPages), arg0, arg1) -} - -// DescribeClassicLinkInstancesPagesWithContext mocks base method. -func (m *MockEC2) DescribeClassicLinkInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 func(*ec2.DescribeClassicLinkInstancesOutput, 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, "DescribeClassicLinkInstancesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClassicLinkInstancesPagesWithContext indicates an expected call of DescribeClassicLinkInstancesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClassicLinkInstancesPagesWithContext(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, "DescribeClassicLinkInstancesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClassicLinkInstancesPagesWithContext), varargs...) -} - -// DescribeClassicLinkInstancesRequest mocks base method. -func (m *MockEC2) DescribeClassicLinkInstancesRequest(arg0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClassicLinkInstancesOutput) - return ret0, ret1 -} - -// DescribeClassicLinkInstancesRequest indicates an expected call of DescribeClassicLinkInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClassicLinkInstancesRequest), arg0) -} - -// DescribeClassicLinkInstancesWithContext mocks base method. -func (m *MockEC2) DescribeClassicLinkInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClassicLinkInstancesWithContext indicates an expected call of DescribeClassicLinkInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeClassicLinkInstancesWithContext(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, "DescribeClassicLinkInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClassicLinkInstancesWithContext), varargs...) -} - -// DescribeClientVpnAuthorizationRules mocks base method. -func (m *MockEC2) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0) - ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules. -func (mr *MockEC2MockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnAuthorizationRules), arg0) -} - -// DescribeClientVpnAuthorizationRulesPages mocks base method. -func (m *MockEC2) DescribeClientVpnAuthorizationRulesPages(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput, arg1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnAuthorizationRulesPages indicates an expected call of DescribeClientVpnAuthorizationRulesPages. -func (mr *MockEC2MockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1) -} - -// DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, 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, "DescribeClientVpnAuthorizationRulesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnAuthorizationRulesPagesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnAuthorizationRulesPagesWithContext(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, "DescribeClientVpnAuthorizationRulesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...) -} - -// DescribeClientVpnAuthorizationRulesRequest mocks base method. -func (m *MockEC2) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput) - return ret0, ret1 -} - -// DescribeClientVpnAuthorizationRulesRequest indicates an expected call of DescribeClientVpnAuthorizationRulesRequest. -func (mr *MockEC2MockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0) -} - -// DescribeClientVpnAuthorizationRulesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnAuthorizationRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnAuthorizationRulesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnAuthorizationRulesWithContext(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, "DescribeClientVpnAuthorizationRulesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...) -} - -// DescribeClientVpnConnections mocks base method. -func (m *MockEC2) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0) - ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections. -func (mr *MockEC2MockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnConnections), arg0) -} - -// DescribeClientVpnConnectionsPages mocks base method. -func (m *MockEC2) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages. -func (mr *MockEC2MockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnConnectionsPages), arg0, arg1) -} - -// DescribeClientVpnConnectionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 func(*ec2.DescribeClientVpnConnectionsOutput, 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, "DescribeClientVpnConnectionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnConnectionsPagesWithContext indicates an expected call of DescribeClientVpnConnectionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnConnectionsPagesWithContext(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, "DescribeClientVpnConnectionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnConnectionsPagesWithContext), varargs...) -} - -// DescribeClientVpnConnectionsRequest mocks base method. -func (m *MockEC2) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput) - return ret0, ret1 -} - -// DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest. -func (mr *MockEC2MockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnConnectionsRequest), arg0) -} - -// DescribeClientVpnConnectionsWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnConnectionsWithContext indicates an expected call of DescribeClientVpnConnectionsWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnConnectionsWithContext(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, "DescribeClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnConnectionsWithContext), varargs...) -} - -// DescribeClientVpnEndpoints mocks base method. -func (m *MockEC2) DescribeClientVpnEndpoints(arg0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnEndpoints", arg0) - ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnEndpoints indicates an expected call of DescribeClientVpnEndpoints. -func (mr *MockEC2MockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnEndpoints), arg0) -} - -// DescribeClientVpnEndpointsPages mocks base method. -func (m *MockEC2) DescribeClientVpnEndpointsPages(arg0 *ec2.DescribeClientVpnEndpointsInput, arg1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnEndpointsPages indicates an expected call of DescribeClientVpnEndpointsPages. -func (mr *MockEC2MockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnEndpointsPages), arg0, arg1) -} - -// DescribeClientVpnEndpointsPagesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 func(*ec2.DescribeClientVpnEndpointsOutput, 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, "DescribeClientVpnEndpointsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnEndpointsPagesWithContext indicates an expected call of DescribeClientVpnEndpointsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnEndpointsPagesWithContext(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, "DescribeClientVpnEndpointsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnEndpointsPagesWithContext), varargs...) -} - -// DescribeClientVpnEndpointsRequest mocks base method. -func (m *MockEC2) DescribeClientVpnEndpointsRequest(arg0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClientVpnEndpointsOutput) - return ret0, ret1 -} - -// DescribeClientVpnEndpointsRequest indicates an expected call of DescribeClientVpnEndpointsRequest. -func (mr *MockEC2MockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnEndpointsRequest), arg0) -} - -// DescribeClientVpnEndpointsWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnEndpointsWithContext indicates an expected call of DescribeClientVpnEndpointsWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnEndpointsWithContext(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, "DescribeClientVpnEndpointsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnEndpointsWithContext), varargs...) -} - -// DescribeClientVpnRoutes mocks base method. -func (m *MockEC2) DescribeClientVpnRoutes(arg0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnRoutes", arg0) - ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnRoutes indicates an expected call of DescribeClientVpnRoutes. -func (mr *MockEC2MockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnRoutes), arg0) -} - -// DescribeClientVpnRoutesPages mocks base method. -func (m *MockEC2) DescribeClientVpnRoutesPages(arg0 *ec2.DescribeClientVpnRoutesInput, arg1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnRoutesPages indicates an expected call of DescribeClientVpnRoutesPages. -func (mr *MockEC2MockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnRoutesPages), arg0, arg1) -} - -// DescribeClientVpnRoutesPagesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 func(*ec2.DescribeClientVpnRoutesOutput, 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, "DescribeClientVpnRoutesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnRoutesPagesWithContext indicates an expected call of DescribeClientVpnRoutesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnRoutesPagesWithContext(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, "DescribeClientVpnRoutesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnRoutesPagesWithContext), varargs...) -} - -// DescribeClientVpnRoutesRequest mocks base method. -func (m *MockEC2) DescribeClientVpnRoutesRequest(arg0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnRoutesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClientVpnRoutesOutput) - return ret0, ret1 -} - -// DescribeClientVpnRoutesRequest indicates an expected call of DescribeClientVpnRoutesRequest. -func (mr *MockEC2MockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnRoutesRequest), arg0) -} - -// DescribeClientVpnRoutesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnRoutesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClientVpnRoutesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnRoutesWithContext indicates an expected call of DescribeClientVpnRoutesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnRoutesWithContext(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, "DescribeClientVpnRoutesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnRoutesWithContext), varargs...) -} - -// DescribeClientVpnTargetNetworks mocks base method. -func (m *MockEC2) DescribeClientVpnTargetNetworks(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworks", arg0) - ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnTargetNetworks indicates an expected call of DescribeClientVpnTargetNetworks. -func (mr *MockEC2MockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnTargetNetworks), arg0) -} - -// DescribeClientVpnTargetNetworksPages mocks base method. -func (m *MockEC2) DescribeClientVpnTargetNetworksPages(arg0 *ec2.DescribeClientVpnTargetNetworksInput, arg1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnTargetNetworksPages indicates an expected call of DescribeClientVpnTargetNetworksPages. -func (mr *MockEC2MockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1) -} - -// DescribeClientVpnTargetNetworksPagesWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnTargetNetworksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 func(*ec2.DescribeClientVpnTargetNetworksOutput, 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, "DescribeClientVpnTargetNetworksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeClientVpnTargetNetworksPagesWithContext indicates an expected call of DescribeClientVpnTargetNetworksPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnTargetNetworksPagesWithContext(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, "DescribeClientVpnTargetNetworksPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnTargetNetworksPagesWithContext), varargs...) -} - -// DescribeClientVpnTargetNetworksRequest mocks base method. -func (m *MockEC2) DescribeClientVpnTargetNetworksRequest(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeClientVpnTargetNetworksOutput) - return ret0, ret1 -} - -// DescribeClientVpnTargetNetworksRequest indicates an expected call of DescribeClientVpnTargetNetworksRequest. -func (mr *MockEC2MockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnTargetNetworksRequest), arg0) -} - -// DescribeClientVpnTargetNetworksWithContext mocks base method. -func (m *MockEC2) DescribeClientVpnTargetNetworksWithContext(arg0 context.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeClientVpnTargetNetworksWithContext indicates an expected call of DescribeClientVpnTargetNetworksWithContext. -func (mr *MockEC2MockRecorder) DescribeClientVpnTargetNetworksWithContext(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, "DescribeClientVpnTargetNetworksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeClientVpnTargetNetworksWithContext), varargs...) -} - -// DescribeCoipPools mocks base method. -func (m *MockEC2) DescribeCoipPools(arg0 *ec2.DescribeCoipPoolsInput) (*ec2.DescribeCoipPoolsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCoipPools", arg0) - ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCoipPools indicates an expected call of DescribeCoipPools. -func (mr *MockEC2MockRecorder) DescribeCoipPools(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPools", reflect.TypeOf((*MockEC2)(nil).DescribeCoipPools), arg0) -} - -// DescribeCoipPoolsPages mocks base method. -func (m *MockEC2) DescribeCoipPoolsPages(arg0 *ec2.DescribeCoipPoolsInput, arg1 func(*ec2.DescribeCoipPoolsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCoipPoolsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCoipPoolsPages indicates an expected call of DescribeCoipPoolsPages. -func (mr *MockEC2MockRecorder) DescribeCoipPoolsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPages", reflect.TypeOf((*MockEC2)(nil).DescribeCoipPoolsPages), arg0, arg1) -} - -// DescribeCoipPoolsPagesWithContext mocks base method. -func (m *MockEC2) DescribeCoipPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 func(*ec2.DescribeCoipPoolsOutput, 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, "DescribeCoipPoolsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeCoipPoolsPagesWithContext indicates an expected call of DescribeCoipPoolsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeCoipPoolsPagesWithContext(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, "DescribeCoipPoolsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCoipPoolsPagesWithContext), varargs...) -} - -// DescribeCoipPoolsRequest mocks base method. -func (m *MockEC2) DescribeCoipPoolsRequest(arg0 *ec2.DescribeCoipPoolsInput) (*request.Request, *ec2.DescribeCoipPoolsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCoipPoolsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCoipPoolsOutput) - return ret0, ret1 -} - -// DescribeCoipPoolsRequest indicates an expected call of DescribeCoipPoolsRequest. -func (mr *MockEC2MockRecorder) DescribeCoipPoolsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCoipPoolsRequest), arg0) -} - -// DescribeCoipPoolsWithContext mocks base method. -func (m *MockEC2) DescribeCoipPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeCoipPoolsInput, arg2 ...request.Option) (*ec2.DescribeCoipPoolsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCoipPoolsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCoipPoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCoipPoolsWithContext indicates an expected call of DescribeCoipPoolsWithContext. -func (mr *MockEC2MockRecorder) DescribeCoipPoolsWithContext(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, "DescribeCoipPoolsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCoipPoolsWithContext), varargs...) -} - -// DescribeConversionTasks mocks base method. -func (m *MockEC2) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeConversionTasks indicates an expected call of DescribeConversionTasks. -func (mr *MockEC2MockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2)(nil).DescribeConversionTasks), arg0) -} - -// DescribeConversionTasksRequest mocks base method. -func (m *MockEC2) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput) - return ret0, ret1 -} - -// DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest. -func (mr *MockEC2MockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeConversionTasksRequest), arg0) -} - -// DescribeConversionTasksWithContext mocks base method. -func (m *MockEC2) DescribeConversionTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeConversionTasksWithContext indicates an expected call of DescribeConversionTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeConversionTasksWithContext(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, "DescribeConversionTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeConversionTasksWithContext), varargs...) -} - -// DescribeCustomerGateways mocks base method. -func (m *MockEC2) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways. -func (mr *MockEC2MockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2)(nil).DescribeCustomerGateways), arg0) -} - -// DescribeCustomerGatewaysRequest mocks base method. -func (m *MockEC2) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput) - return ret0, ret1 -} - -// DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeCustomerGatewaysRequest), arg0) -} - -// DescribeCustomerGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeCustomerGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeCustomerGatewaysWithContext indicates an expected call of DescribeCustomerGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeCustomerGatewaysWithContext(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, "DescribeCustomerGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeCustomerGatewaysWithContext), varargs...) -} - -// DescribeDhcpOptions mocks base method. -func (m *MockEC2) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0) - ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions. -func (mr *MockEC2MockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2)(nil).DescribeDhcpOptions), arg0) -} - -// DescribeDhcpOptionsPages mocks base method. -func (m *MockEC2) DescribeDhcpOptionsPages(arg0 *ec2.DescribeDhcpOptionsInput, arg1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDhcpOptionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeDhcpOptionsPages indicates an expected call of DescribeDhcpOptionsPages. -func (mr *MockEC2MockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeDhcpOptionsPages), arg0, arg1) -} - -// DescribeDhcpOptionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeDhcpOptionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 func(*ec2.DescribeDhcpOptionsOutput, 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, "DescribeDhcpOptionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeDhcpOptionsPagesWithContext indicates an expected call of DescribeDhcpOptionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeDhcpOptionsPagesWithContext(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, "DescribeDhcpOptionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeDhcpOptionsPagesWithContext), varargs...) -} - -// DescribeDhcpOptionsRequest mocks base method. -func (m *MockEC2) DescribeDhcpOptionsRequest(arg0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDhcpOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeDhcpOptionsOutput) - return ret0, ret1 -} - -// DescribeDhcpOptionsRequest indicates an expected call of DescribeDhcpOptionsRequest. -func (mr *MockEC2MockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeDhcpOptionsRequest), arg0) -} - -// DescribeDhcpOptionsWithContext mocks base method. -func (m *MockEC2) DescribeDhcpOptionsWithContext(arg0 context.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeDhcpOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDhcpOptionsWithContext indicates an expected call of DescribeDhcpOptionsWithContext. -func (mr *MockEC2MockRecorder) DescribeDhcpOptionsWithContext(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, "DescribeDhcpOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeDhcpOptionsWithContext), varargs...) -} - -// DescribeEgressOnlyInternetGateways mocks base method. -func (m *MockEC2) DescribeEgressOnlyInternetGateways(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways. -func (mr *MockEC2MockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2)(nil).DescribeEgressOnlyInternetGateways), arg0) -} - -// DescribeEgressOnlyInternetGatewaysPages mocks base method. -func (m *MockEC2) DescribeEgressOnlyInternetGatewaysPages(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEgressOnlyInternetGatewaysPages indicates an expected call of DescribeEgressOnlyInternetGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1) -} - -// DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, 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, "DescribeEgressOnlyInternetGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeEgressOnlyInternetGatewaysPagesWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeEgressOnlyInternetGatewaysPagesWithContext(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, "DescribeEgressOnlyInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeEgressOnlyInternetGatewaysPagesWithContext), varargs...) -} - -// DescribeEgressOnlyInternetGatewaysRequest mocks base method. -func (m *MockEC2) DescribeEgressOnlyInternetGatewaysRequest(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) - return ret0, ret1 -} - -// DescribeEgressOnlyInternetGatewaysRequest indicates an expected call of DescribeEgressOnlyInternetGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0) -} - -// DescribeEgressOnlyInternetGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeEgressOnlyInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEgressOnlyInternetGatewaysWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeEgressOnlyInternetGatewaysWithContext(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, "DescribeEgressOnlyInternetGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeEgressOnlyInternetGatewaysWithContext), varargs...) -} - -// DescribeElasticGpus mocks base method. -func (m *MockEC2) DescribeElasticGpus(arg0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeElasticGpus", arg0) - ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeElasticGpus indicates an expected call of DescribeElasticGpus. -func (mr *MockEC2MockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2)(nil).DescribeElasticGpus), arg0) -} - -// DescribeElasticGpusRequest mocks base method. -func (m *MockEC2) DescribeElasticGpusRequest(arg0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeElasticGpusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeElasticGpusOutput) - return ret0, ret1 -} - -// DescribeElasticGpusRequest indicates an expected call of DescribeElasticGpusRequest. -func (mr *MockEC2MockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2)(nil).DescribeElasticGpusRequest), arg0) -} - -// DescribeElasticGpusWithContext mocks base method. -func (m *MockEC2) DescribeElasticGpusWithContext(arg0 context.Context, arg1 *ec2.DescribeElasticGpusInput, arg2 ...request.Option) (*ec2.DescribeElasticGpusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeElasticGpusWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeElasticGpusWithContext indicates an expected call of DescribeElasticGpusWithContext. -func (mr *MockEC2MockRecorder) DescribeElasticGpusWithContext(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, "DescribeElasticGpusWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeElasticGpusWithContext), varargs...) -} - -// DescribeExportImageTasks mocks base method. -func (m *MockEC2) DescribeExportImageTasks(arg0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeExportImageTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeExportImageTasks indicates an expected call of DescribeExportImageTasks. -func (mr *MockEC2MockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2)(nil).DescribeExportImageTasks), arg0) -} - -// DescribeExportImageTasksPages mocks base method. -func (m *MockEC2) DescribeExportImageTasksPages(arg0 *ec2.DescribeExportImageTasksInput, arg1 func(*ec2.DescribeExportImageTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeExportImageTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeExportImageTasksPages indicates an expected call of DescribeExportImageTasksPages. -func (mr *MockEC2MockRecorder) DescribeExportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPages", reflect.TypeOf((*MockEC2)(nil).DescribeExportImageTasksPages), arg0, arg1) -} - -// DescribeExportImageTasksPagesWithContext mocks base method. -func (m *MockEC2) DescribeExportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 func(*ec2.DescribeExportImageTasksOutput, 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, "DescribeExportImageTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeExportImageTasksPagesWithContext indicates an expected call of DescribeExportImageTasksPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeExportImageTasksPagesWithContext(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, "DescribeExportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeExportImageTasksPagesWithContext), varargs...) -} - -// DescribeExportImageTasksRequest mocks base method. -func (m *MockEC2) DescribeExportImageTasksRequest(arg0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeExportImageTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeExportImageTasksOutput) - return ret0, ret1 -} - -// DescribeExportImageTasksRequest indicates an expected call of DescribeExportImageTasksRequest. -func (mr *MockEC2MockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeExportImageTasksRequest), arg0) -} - -// DescribeExportImageTasksWithContext mocks base method. -func (m *MockEC2) DescribeExportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeExportImageTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeExportImageTasksWithContext indicates an expected call of DescribeExportImageTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeExportImageTasksWithContext(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, "DescribeExportImageTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeExportImageTasksWithContext), varargs...) -} - -// DescribeExportTasks mocks base method. -func (m *MockEC2) DescribeExportTasks(arg0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeExportTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeExportTasks indicates an expected call of DescribeExportTasks. -func (mr *MockEC2MockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2)(nil).DescribeExportTasks), arg0) -} - -// DescribeExportTasksRequest mocks base method. -func (m *MockEC2) DescribeExportTasksRequest(arg0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeExportTasksOutput) - return ret0, ret1 -} - -// DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest. -func (mr *MockEC2MockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeExportTasksRequest), arg0) -} - -// DescribeExportTasksWithContext mocks base method. -func (m *MockEC2) DescribeExportTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.Option) (*ec2.DescribeExportTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeExportTasksWithContext indicates an expected call of DescribeExportTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeExportTasksWithContext(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, "DescribeExportTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeExportTasksWithContext), varargs...) -} - -// DescribeFastLaunchImages mocks base method. -func (m *MockEC2) DescribeFastLaunchImages(arg0 *ec2.DescribeFastLaunchImagesInput) (*ec2.DescribeFastLaunchImagesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastLaunchImages", arg0) - ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFastLaunchImages indicates an expected call of DescribeFastLaunchImages. -func (mr *MockEC2MockRecorder) DescribeFastLaunchImages(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImages", reflect.TypeOf((*MockEC2)(nil).DescribeFastLaunchImages), arg0) -} - -// DescribeFastLaunchImagesPages mocks base method. -func (m *MockEC2) DescribeFastLaunchImagesPages(arg0 *ec2.DescribeFastLaunchImagesInput, arg1 func(*ec2.DescribeFastLaunchImagesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastLaunchImagesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFastLaunchImagesPages indicates an expected call of DescribeFastLaunchImagesPages. -func (mr *MockEC2MockRecorder) DescribeFastLaunchImagesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesPages", reflect.TypeOf((*MockEC2)(nil).DescribeFastLaunchImagesPages), arg0, arg1) -} - -// DescribeFastLaunchImagesPagesWithContext mocks base method. -func (m *MockEC2) DescribeFastLaunchImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 func(*ec2.DescribeFastLaunchImagesOutput, 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, "DescribeFastLaunchImagesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFastLaunchImagesPagesWithContext indicates an expected call of DescribeFastLaunchImagesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFastLaunchImagesPagesWithContext(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, "DescribeFastLaunchImagesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFastLaunchImagesPagesWithContext), varargs...) -} - -// DescribeFastLaunchImagesRequest mocks base method. -func (m *MockEC2) DescribeFastLaunchImagesRequest(arg0 *ec2.DescribeFastLaunchImagesInput) (*request.Request, *ec2.DescribeFastLaunchImagesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastLaunchImagesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFastLaunchImagesOutput) - return ret0, ret1 -} - -// DescribeFastLaunchImagesRequest indicates an expected call of DescribeFastLaunchImagesRequest. -func (mr *MockEC2MockRecorder) DescribeFastLaunchImagesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastLaunchImagesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFastLaunchImagesRequest), arg0) -} - -// DescribeFastLaunchImagesWithContext mocks base method. -func (m *MockEC2) DescribeFastLaunchImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastLaunchImagesInput, arg2 ...request.Option) (*ec2.DescribeFastLaunchImagesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFastLaunchImagesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFastLaunchImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFastLaunchImagesWithContext indicates an expected call of DescribeFastLaunchImagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFastLaunchImagesWithContext(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, "DescribeFastLaunchImagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFastLaunchImagesWithContext), varargs...) -} - -// DescribeFastSnapshotRestores mocks base method. -func (m *MockEC2) DescribeFastSnapshotRestores(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*ec2.DescribeFastSnapshotRestoresOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastSnapshotRestores", arg0) - ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFastSnapshotRestores indicates an expected call of DescribeFastSnapshotRestores. -func (mr *MockEC2MockRecorder) DescribeFastSnapshotRestores(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestores", reflect.TypeOf((*MockEC2)(nil).DescribeFastSnapshotRestores), arg0) -} - -// DescribeFastSnapshotRestoresPages mocks base method. -func (m *MockEC2) DescribeFastSnapshotRestoresPages(arg0 *ec2.DescribeFastSnapshotRestoresInput, arg1 func(*ec2.DescribeFastSnapshotRestoresOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFastSnapshotRestoresPages indicates an expected call of DescribeFastSnapshotRestoresPages. -func (mr *MockEC2MockRecorder) DescribeFastSnapshotRestoresPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPages", reflect.TypeOf((*MockEC2)(nil).DescribeFastSnapshotRestoresPages), arg0, arg1) -} - -// DescribeFastSnapshotRestoresPagesWithContext mocks base method. -func (m *MockEC2) DescribeFastSnapshotRestoresPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 func(*ec2.DescribeFastSnapshotRestoresOutput, 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, "DescribeFastSnapshotRestoresPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFastSnapshotRestoresPagesWithContext indicates an expected call of DescribeFastSnapshotRestoresPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFastSnapshotRestoresPagesWithContext(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, "DescribeFastSnapshotRestoresPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFastSnapshotRestoresPagesWithContext), varargs...) -} - -// DescribeFastSnapshotRestoresRequest mocks base method. -func (m *MockEC2) DescribeFastSnapshotRestoresRequest(arg0 *ec2.DescribeFastSnapshotRestoresInput) (*request.Request, *ec2.DescribeFastSnapshotRestoresOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFastSnapshotRestoresOutput) - return ret0, ret1 -} - -// DescribeFastSnapshotRestoresRequest indicates an expected call of DescribeFastSnapshotRestoresRequest. -func (mr *MockEC2MockRecorder) DescribeFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFastSnapshotRestoresRequest), arg0) -} - -// DescribeFastSnapshotRestoresWithContext mocks base method. -func (m *MockEC2) DescribeFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DescribeFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DescribeFastSnapshotRestoresOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFastSnapshotRestoresWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFastSnapshotRestoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFastSnapshotRestoresWithContext indicates an expected call of DescribeFastSnapshotRestoresWithContext. -func (mr *MockEC2MockRecorder) DescribeFastSnapshotRestoresWithContext(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, "DescribeFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFastSnapshotRestoresWithContext), varargs...) -} - -// DescribeFleetHistory mocks base method. -func (m *MockEC2) DescribeFleetHistory(arg0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetHistory", arg0) - ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleetHistory indicates an expected call of DescribeFleetHistory. -func (mr *MockEC2MockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2)(nil).DescribeFleetHistory), arg0) -} - -// DescribeFleetHistoryRequest mocks base method. -func (m *MockEC2) DescribeFleetHistoryRequest(arg0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFleetHistoryOutput) - return ret0, ret1 -} - -// DescribeFleetHistoryRequest indicates an expected call of DescribeFleetHistoryRequest. -func (mr *MockEC2MockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFleetHistoryRequest), arg0) -} - -// DescribeFleetHistoryWithContext mocks base method. -func (m *MockEC2) DescribeFleetHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetHistoryInput, arg2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFleetHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleetHistoryWithContext indicates an expected call of DescribeFleetHistoryWithContext. -func (mr *MockEC2MockRecorder) DescribeFleetHistoryWithContext(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, "DescribeFleetHistoryWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFleetHistoryWithContext), varargs...) -} - -// DescribeFleetInstances mocks base method. -func (m *MockEC2) DescribeFleetInstances(arg0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleetInstances indicates an expected call of DescribeFleetInstances. -func (mr *MockEC2MockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2)(nil).DescribeFleetInstances), arg0) -} - -// DescribeFleetInstancesRequest mocks base method. -func (m *MockEC2) DescribeFleetInstancesRequest(arg0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFleetInstancesOutput) - return ret0, ret1 -} - -// DescribeFleetInstancesRequest indicates an expected call of DescribeFleetInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFleetInstancesRequest), arg0) -} - -// DescribeFleetInstancesWithContext mocks base method. -func (m *MockEC2) DescribeFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFleetInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleetInstancesWithContext indicates an expected call of DescribeFleetInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeFleetInstancesWithContext(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, "DescribeFleetInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFleetInstancesWithContext), varargs...) -} - -// DescribeFleets mocks base method. -func (m *MockEC2) DescribeFleets(arg0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleets", arg0) - ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleets indicates an expected call of DescribeFleets. -func (mr *MockEC2MockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2)(nil).DescribeFleets), arg0) -} - -// DescribeFleetsPages mocks base method. -func (m *MockEC2) DescribeFleetsPages(arg0 *ec2.DescribeFleetsInput, arg1 func(*ec2.DescribeFleetsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFleetsPages indicates an expected call of DescribeFleetsPages. -func (mr *MockEC2MockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2)(nil).DescribeFleetsPages), arg0, arg1) -} - -// DescribeFleetsPagesWithContext mocks base method. -func (m *MockEC2) DescribeFleetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 func(*ec2.DescribeFleetsOutput, 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, "DescribeFleetsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFleetsPagesWithContext indicates an expected call of DescribeFleetsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFleetsPagesWithContext(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, "DescribeFleetsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFleetsPagesWithContext), varargs...) -} - -// DescribeFleetsRequest mocks base method. -func (m *MockEC2) DescribeFleetsRequest(arg0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFleetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFleetsOutput) - return ret0, ret1 -} - -// DescribeFleetsRequest indicates an expected call of DescribeFleetsRequest. -func (mr *MockEC2MockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFleetsRequest), arg0) -} - -// DescribeFleetsWithContext mocks base method. -func (m *MockEC2) DescribeFleetsWithContext(arg0 context.Context, arg1 *ec2.DescribeFleetsInput, arg2 ...request.Option) (*ec2.DescribeFleetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFleetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFleetsWithContext indicates an expected call of DescribeFleetsWithContext. -func (mr *MockEC2MockRecorder) DescribeFleetsWithContext(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, "DescribeFleetsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFleetsWithContext), varargs...) -} - -// DescribeFlowLogs mocks base method. -func (m *MockEC2) DescribeFlowLogs(arg0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFlowLogs", arg0) - ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFlowLogs indicates an expected call of DescribeFlowLogs. -func (mr *MockEC2MockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2)(nil).DescribeFlowLogs), arg0) -} - -// DescribeFlowLogsPages mocks base method. -func (m *MockEC2) DescribeFlowLogsPages(arg0 *ec2.DescribeFlowLogsInput, arg1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFlowLogsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFlowLogsPages indicates an expected call of DescribeFlowLogsPages. -func (mr *MockEC2MockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2)(nil).DescribeFlowLogsPages), arg0, arg1) -} - -// DescribeFlowLogsPagesWithContext mocks base method. -func (m *MockEC2) DescribeFlowLogsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 func(*ec2.DescribeFlowLogsOutput, 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, "DescribeFlowLogsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFlowLogsPagesWithContext indicates an expected call of DescribeFlowLogsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFlowLogsPagesWithContext(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, "DescribeFlowLogsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFlowLogsPagesWithContext), varargs...) -} - -// DescribeFlowLogsRequest mocks base method. -func (m *MockEC2) DescribeFlowLogsRequest(arg0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFlowLogsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFlowLogsOutput) - return ret0, ret1 -} - -// DescribeFlowLogsRequest indicates an expected call of DescribeFlowLogsRequest. -func (mr *MockEC2MockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFlowLogsRequest), arg0) -} - -// DescribeFlowLogsWithContext mocks base method. -func (m *MockEC2) DescribeFlowLogsWithContext(arg0 context.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 ...request.Option) (*ec2.DescribeFlowLogsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFlowLogsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFlowLogsWithContext indicates an expected call of DescribeFlowLogsWithContext. -func (mr *MockEC2MockRecorder) DescribeFlowLogsWithContext(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, "DescribeFlowLogsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFlowLogsWithContext), varargs...) -} - -// DescribeFpgaImageAttribute mocks base method. -func (m *MockEC2) DescribeFpgaImageAttribute(arg0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFpgaImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFpgaImageAttribute indicates an expected call of DescribeFpgaImageAttribute. -func (mr *MockEC2MockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImageAttribute), arg0) -} - -// DescribeFpgaImageAttributeRequest mocks base method. -func (m *MockEC2) DescribeFpgaImageAttributeRequest(arg0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFpgaImageAttributeOutput) - return ret0, ret1 -} - -// DescribeFpgaImageAttributeRequest indicates an expected call of DescribeFpgaImageAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImageAttributeRequest), arg0) -} - -// DescribeFpgaImageAttributeWithContext mocks base method. -func (m *MockEC2) DescribeFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFpgaImageAttributeWithContext indicates an expected call of DescribeFpgaImageAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeFpgaImageAttributeWithContext(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, "DescribeFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImageAttributeWithContext), varargs...) -} - -// DescribeFpgaImages mocks base method. -func (m *MockEC2) DescribeFpgaImages(arg0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFpgaImages", arg0) - ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFpgaImages indicates an expected call of DescribeFpgaImages. -func (mr *MockEC2MockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImages), arg0) -} - -// DescribeFpgaImagesPages mocks base method. -func (m *MockEC2) DescribeFpgaImagesPages(arg0 *ec2.DescribeFpgaImagesInput, arg1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFpgaImagesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFpgaImagesPages indicates an expected call of DescribeFpgaImagesPages. -func (mr *MockEC2MockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImagesPages), arg0, arg1) -} - -// DescribeFpgaImagesPagesWithContext mocks base method. -func (m *MockEC2) DescribeFpgaImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 func(*ec2.DescribeFpgaImagesOutput, 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, "DescribeFpgaImagesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeFpgaImagesPagesWithContext indicates an expected call of DescribeFpgaImagesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFpgaImagesPagesWithContext(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, "DescribeFpgaImagesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImagesPagesWithContext), varargs...) -} - -// DescribeFpgaImagesRequest mocks base method. -func (m *MockEC2) DescribeFpgaImagesRequest(arg0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeFpgaImagesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeFpgaImagesOutput) - return ret0, ret1 -} - -// DescribeFpgaImagesRequest indicates an expected call of DescribeFpgaImagesRequest. -func (mr *MockEC2MockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImagesRequest), arg0) -} - -// DescribeFpgaImagesWithContext mocks base method. -func (m *MockEC2) DescribeFpgaImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeFpgaImagesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeFpgaImagesWithContext indicates an expected call of DescribeFpgaImagesWithContext. -func (mr *MockEC2MockRecorder) DescribeFpgaImagesWithContext(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, "DescribeFpgaImagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeFpgaImagesWithContext), varargs...) -} - -// DescribeHostReservationOfferings mocks base method. -func (m *MockEC2) DescribeHostReservationOfferings(arg0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservationOfferings", arg0) - ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHostReservationOfferings indicates an expected call of DescribeHostReservationOfferings. -func (mr *MockEC2MockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationOfferings), arg0) -} - -// DescribeHostReservationOfferingsPages mocks base method. -func (m *MockEC2) DescribeHostReservationOfferingsPages(arg0 *ec2.DescribeHostReservationOfferingsInput, arg1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostReservationOfferingsPages indicates an expected call of DescribeHostReservationOfferingsPages. -func (mr *MockEC2MockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationOfferingsPages), arg0, arg1) -} - -// DescribeHostReservationOfferingsPagesWithContext mocks base method. -func (m *MockEC2) DescribeHostReservationOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 func(*ec2.DescribeHostReservationOfferingsOutput, 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, "DescribeHostReservationOfferingsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostReservationOfferingsPagesWithContext indicates an expected call of DescribeHostReservationOfferingsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeHostReservationOfferingsPagesWithContext(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, "DescribeHostReservationOfferingsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationOfferingsPagesWithContext), varargs...) -} - -// DescribeHostReservationOfferingsRequest mocks base method. -func (m *MockEC2) DescribeHostReservationOfferingsRequest(arg0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeHostReservationOfferingsOutput) - return ret0, ret1 -} - -// DescribeHostReservationOfferingsRequest indicates an expected call of DescribeHostReservationOfferingsRequest. -func (mr *MockEC2MockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationOfferingsRequest), arg0) -} - -// DescribeHostReservationOfferingsWithContext mocks base method. -func (m *MockEC2) DescribeHostReservationOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHostReservationOfferingsWithContext indicates an expected call of DescribeHostReservationOfferingsWithContext. -func (mr *MockEC2MockRecorder) DescribeHostReservationOfferingsWithContext(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, "DescribeHostReservationOfferingsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationOfferingsWithContext), varargs...) -} - -// DescribeHostReservations mocks base method. -func (m *MockEC2) DescribeHostReservations(arg0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservations", arg0) - ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHostReservations indicates an expected call of DescribeHostReservations. -func (mr *MockEC2MockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservations), arg0) -} - -// DescribeHostReservationsPages mocks base method. -func (m *MockEC2) DescribeHostReservationsPages(arg0 *ec2.DescribeHostReservationsInput, arg1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostReservationsPages indicates an expected call of DescribeHostReservationsPages. -func (mr *MockEC2MockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationsPages), arg0, arg1) -} - -// DescribeHostReservationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeHostReservationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 func(*ec2.DescribeHostReservationsOutput, 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, "DescribeHostReservationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostReservationsPagesWithContext indicates an expected call of DescribeHostReservationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeHostReservationsPagesWithContext(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, "DescribeHostReservationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationsPagesWithContext), varargs...) -} - -// DescribeHostReservationsRequest mocks base method. -func (m *MockEC2) DescribeHostReservationsRequest(arg0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostReservationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeHostReservationsOutput) - return ret0, ret1 -} - -// DescribeHostReservationsRequest indicates an expected call of DescribeHostReservationsRequest. -func (mr *MockEC2MockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationsRequest), arg0) -} - -// DescribeHostReservationsWithContext mocks base method. -func (m *MockEC2) DescribeHostReservationsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeHostReservationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHostReservationsWithContext indicates an expected call of DescribeHostReservationsWithContext. -func (mr *MockEC2MockRecorder) DescribeHostReservationsWithContext(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, "DescribeHostReservationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostReservationsWithContext), varargs...) -} - -// DescribeHosts mocks base method. -func (m *MockEC2) DescribeHosts(arg0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHosts", arg0) - ret0, _ := ret[0].(*ec2.DescribeHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHosts indicates an expected call of DescribeHosts. -func (mr *MockEC2MockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2)(nil).DescribeHosts), arg0) -} - -// DescribeHostsPages mocks base method. -func (m *MockEC2) DescribeHostsPages(arg0 *ec2.DescribeHostsInput, arg1 func(*ec2.DescribeHostsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostsPages indicates an expected call of DescribeHostsPages. -func (mr *MockEC2MockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2)(nil).DescribeHostsPages), arg0, arg1) -} - -// DescribeHostsPagesWithContext mocks base method. -func (m *MockEC2) DescribeHostsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 func(*ec2.DescribeHostsOutput, 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, "DescribeHostsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeHostsPagesWithContext indicates an expected call of DescribeHostsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeHostsPagesWithContext(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, "DescribeHostsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostsPagesWithContext), varargs...) -} - -// DescribeHostsRequest mocks base method. -func (m *MockEC2) DescribeHostsRequest(arg0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeHostsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeHostsOutput) - return ret0, ret1 -} - -// DescribeHostsRequest indicates an expected call of DescribeHostsRequest. -func (mr *MockEC2MockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeHostsRequest), arg0) -} - -// DescribeHostsWithContext mocks base method. -func (m *MockEC2) DescribeHostsWithContext(arg0 context.Context, arg1 *ec2.DescribeHostsInput, arg2 ...request.Option) (*ec2.DescribeHostsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeHostsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeHostsWithContext indicates an expected call of DescribeHostsWithContext. -func (mr *MockEC2MockRecorder) DescribeHostsWithContext(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, "DescribeHostsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeHostsWithContext), varargs...) -} - -// DescribeIamInstanceProfileAssociations mocks base method. -func (m *MockEC2) DescribeIamInstanceProfileAssociations(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociations", arg0) - ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIamInstanceProfileAssociations indicates an expected call of DescribeIamInstanceProfileAssociations. -func (mr *MockEC2MockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2)(nil).DescribeIamInstanceProfileAssociations), arg0) -} - -// DescribeIamInstanceProfileAssociationsPages mocks base method. -func (m *MockEC2) DescribeIamInstanceProfileAssociationsPages(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput, arg1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIamInstanceProfileAssociationsPages indicates an expected call of DescribeIamInstanceProfileAssociationsPages. -func (mr *MockEC2MockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1) -} - -// DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, 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, "DescribeIamInstanceProfileAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIamInstanceProfileAssociationsPagesWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIamInstanceProfileAssociationsPagesWithContext(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, "DescribeIamInstanceProfileAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIamInstanceProfileAssociationsPagesWithContext), varargs...) -} - -// DescribeIamInstanceProfileAssociationsRequest mocks base method. -func (m *MockEC2) DescribeIamInstanceProfileAssociationsRequest(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIamInstanceProfileAssociationsOutput) - return ret0, ret1 -} - -// DescribeIamInstanceProfileAssociationsRequest indicates an expected call of DescribeIamInstanceProfileAssociationsRequest. -func (mr *MockEC2MockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0) -} - -// DescribeIamInstanceProfileAssociationsWithContext mocks base method. -func (m *MockEC2) DescribeIamInstanceProfileAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIamInstanceProfileAssociationsWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsWithContext. -func (mr *MockEC2MockRecorder) DescribeIamInstanceProfileAssociationsWithContext(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, "DescribeIamInstanceProfileAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIamInstanceProfileAssociationsWithContext), varargs...) -} - -// DescribeIdFormat mocks base method. -func (m *MockEC2) DescribeIdFormat(arg0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIdFormat", arg0) - ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIdFormat indicates an expected call of DescribeIdFormat. -func (mr *MockEC2MockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2)(nil).DescribeIdFormat), arg0) -} - -// DescribeIdFormatRequest mocks base method. -func (m *MockEC2) DescribeIdFormatRequest(arg0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIdFormatOutput) - return ret0, ret1 -} - -// DescribeIdFormatRequest indicates an expected call of DescribeIdFormatRequest. -func (mr *MockEC2MockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIdFormatRequest), arg0) -} - -// DescribeIdFormatWithContext mocks base method. -func (m *MockEC2) DescribeIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIdFormatWithContext indicates an expected call of DescribeIdFormatWithContext. -func (mr *MockEC2MockRecorder) DescribeIdFormatWithContext(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, "DescribeIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIdFormatWithContext), varargs...) -} - -// DescribeIdentityIdFormat mocks base method. -func (m *MockEC2) DescribeIdentityIdFormat(arg0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIdentityIdFormat", arg0) - ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIdentityIdFormat indicates an expected call of DescribeIdentityIdFormat. -func (mr *MockEC2MockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2)(nil).DescribeIdentityIdFormat), arg0) -} - -// DescribeIdentityIdFormatRequest mocks base method. -func (m *MockEC2) DescribeIdentityIdFormatRequest(arg0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIdentityIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIdentityIdFormatOutput) - return ret0, ret1 -} - -// DescribeIdentityIdFormatRequest indicates an expected call of DescribeIdentityIdFormatRequest. -func (mr *MockEC2MockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIdentityIdFormatRequest), arg0) -} - -// DescribeIdentityIdFormatWithContext mocks base method. -func (m *MockEC2) DescribeIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribeIdentityIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIdentityIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIdentityIdFormatWithContext indicates an expected call of DescribeIdentityIdFormatWithContext. -func (mr *MockEC2MockRecorder) DescribeIdentityIdFormatWithContext(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, "DescribeIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIdentityIdFormatWithContext), varargs...) -} - -// DescribeImageAttribute mocks base method. -func (m *MockEC2) DescribeImageAttribute(arg0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImageAttribute indicates an expected call of DescribeImageAttribute. -func (mr *MockEC2MockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeImageAttribute), arg0) -} - -// DescribeImageAttributeRequest mocks base method. -func (m *MockEC2) DescribeImageAttributeRequest(arg0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeImageAttributeOutput) - return ret0, ret1 -} - -// DescribeImageAttributeRequest indicates an expected call of DescribeImageAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeImageAttributeRequest), arg0) -} - -// DescribeImageAttributeWithContext mocks base method. -func (m *MockEC2) DescribeImageAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImageAttributeWithContext indicates an expected call of DescribeImageAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeImageAttributeWithContext(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, "DescribeImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImageAttributeWithContext), varargs...) -} - -// DescribeImages mocks base method. -func (m *MockEC2) DescribeImages(arg0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImages", arg0) - ret0, _ := ret[0].(*ec2.DescribeImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImages indicates an expected call of DescribeImages. -func (mr *MockEC2MockRecorder) DescribeImages(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2)(nil).DescribeImages), arg0) -} - -// DescribeImagesPages mocks base method. -func (m *MockEC2) DescribeImagesPages(arg0 *ec2.DescribeImagesInput, arg1 func(*ec2.DescribeImagesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImagesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImagesPages indicates an expected call of DescribeImagesPages. -func (mr *MockEC2MockRecorder) DescribeImagesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesPages", reflect.TypeOf((*MockEC2)(nil).DescribeImagesPages), arg0, arg1) -} - -// DescribeImagesPagesWithContext mocks base method. -func (m *MockEC2) DescribeImagesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 func(*ec2.DescribeImagesOutput, 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, "DescribeImagesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImagesPagesWithContext indicates an expected call of DescribeImagesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeImagesPagesWithContext(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, "DescribeImagesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImagesPagesWithContext), varargs...) -} - -// DescribeImagesRequest mocks base method. -func (m *MockEC2) DescribeImagesRequest(arg0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeImagesOutput) - return ret0, ret1 -} - -// DescribeImagesRequest indicates an expected call of DescribeImagesRequest. -func (mr *MockEC2MockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeImagesRequest), arg0) -} - -// DescribeImagesWithContext mocks base method. -func (m *MockEC2) DescribeImagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.Option) (*ec2.DescribeImagesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeImagesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImagesWithContext indicates an expected call of DescribeImagesWithContext. -func (mr *MockEC2MockRecorder) DescribeImagesWithContext(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, "DescribeImagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImagesWithContext), varargs...) -} - -// DescribeImportImageTasks mocks base method. -func (m *MockEC2) DescribeImportImageTasks(arg0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportImageTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImportImageTasks indicates an expected call of DescribeImportImageTasks. -func (mr *MockEC2MockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2)(nil).DescribeImportImageTasks), arg0) -} - -// DescribeImportImageTasksPages mocks base method. -func (m *MockEC2) DescribeImportImageTasksPages(arg0 *ec2.DescribeImportImageTasksInput, arg1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportImageTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImportImageTasksPages indicates an expected call of DescribeImportImageTasksPages. -func (mr *MockEC2MockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2)(nil).DescribeImportImageTasksPages), arg0, arg1) -} - -// DescribeImportImageTasksPagesWithContext mocks base method. -func (m *MockEC2) DescribeImportImageTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 func(*ec2.DescribeImportImageTasksOutput, 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, "DescribeImportImageTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImportImageTasksPagesWithContext indicates an expected call of DescribeImportImageTasksPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeImportImageTasksPagesWithContext(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, "DescribeImportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImportImageTasksPagesWithContext), varargs...) -} - -// DescribeImportImageTasksRequest mocks base method. -func (m *MockEC2) DescribeImportImageTasksRequest(arg0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportImageTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeImportImageTasksOutput) - return ret0, ret1 -} - -// DescribeImportImageTasksRequest indicates an expected call of DescribeImportImageTasksRequest. -func (mr *MockEC2MockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeImportImageTasksRequest), arg0) -} - -// DescribeImportImageTasksWithContext mocks base method. -func (m *MockEC2) DescribeImportImageTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeImportImageTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImportImageTasksWithContext indicates an expected call of DescribeImportImageTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeImportImageTasksWithContext(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, "DescribeImportImageTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImportImageTasksWithContext), varargs...) -} - -// DescribeImportSnapshotTasks mocks base method. -func (m *MockEC2) DescribeImportSnapshotTasks(arg0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportSnapshotTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImportSnapshotTasks indicates an expected call of DescribeImportSnapshotTasks. -func (mr *MockEC2MockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2)(nil).DescribeImportSnapshotTasks), arg0) -} - -// DescribeImportSnapshotTasksPages mocks base method. -func (m *MockEC2) DescribeImportSnapshotTasksPages(arg0 *ec2.DescribeImportSnapshotTasksInput, arg1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImportSnapshotTasksPages indicates an expected call of DescribeImportSnapshotTasksPages. -func (mr *MockEC2MockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2)(nil).DescribeImportSnapshotTasksPages), arg0, arg1) -} - -// DescribeImportSnapshotTasksPagesWithContext mocks base method. -func (m *MockEC2) DescribeImportSnapshotTasksPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 func(*ec2.DescribeImportSnapshotTasksOutput, 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, "DescribeImportSnapshotTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeImportSnapshotTasksPagesWithContext indicates an expected call of DescribeImportSnapshotTasksPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeImportSnapshotTasksPagesWithContext(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, "DescribeImportSnapshotTasksPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImportSnapshotTasksPagesWithContext), varargs...) -} - -// DescribeImportSnapshotTasksRequest mocks base method. -func (m *MockEC2) DescribeImportSnapshotTasksRequest(arg0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeImportSnapshotTasksOutput) - return ret0, ret1 -} - -// DescribeImportSnapshotTasksRequest indicates an expected call of DescribeImportSnapshotTasksRequest. -func (mr *MockEC2MockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeImportSnapshotTasksRequest), arg0) -} - -// DescribeImportSnapshotTasksWithContext mocks base method. -func (m *MockEC2) DescribeImportSnapshotTasksWithContext(arg0 context.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeImportSnapshotTasksWithContext indicates an expected call of DescribeImportSnapshotTasksWithContext. -func (mr *MockEC2MockRecorder) DescribeImportSnapshotTasksWithContext(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, "DescribeImportSnapshotTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeImportSnapshotTasksWithContext), varargs...) -} - -// DescribeInstanceAttribute mocks base method. -func (m *MockEC2) DescribeInstanceAttribute(arg0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceAttribute indicates an expected call of DescribeInstanceAttribute. -func (mr *MockEC2MockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceAttribute), arg0) -} - -// DescribeInstanceAttributeRequest mocks base method. -func (m *MockEC2) DescribeInstanceAttributeRequest(arg0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceAttributeOutput) - return ret0, ret1 -} - -// DescribeInstanceAttributeRequest indicates an expected call of DescribeInstanceAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceAttributeRequest), arg0) -} - -// DescribeInstanceAttributeWithContext mocks base method. -func (m *MockEC2) DescribeInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceAttributeInput, arg2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceAttributeWithContext indicates an expected call of DescribeInstanceAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceAttributeWithContext(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, "DescribeInstanceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceAttributeWithContext), varargs...) -} - -// DescribeInstanceConnectEndpoints mocks base method. -func (m *MockEC2) DescribeInstanceConnectEndpoints(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*ec2.DescribeInstanceConnectEndpointsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpoints", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceConnectEndpoints indicates an expected call of DescribeInstanceConnectEndpoints. -func (mr *MockEC2MockRecorder) DescribeInstanceConnectEndpoints(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpoints", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceConnectEndpoints), arg0) -} - -// DescribeInstanceConnectEndpointsPages mocks base method. -func (m *MockEC2) DescribeInstanceConnectEndpointsPages(arg0 *ec2.DescribeInstanceConnectEndpointsInput, arg1 func(*ec2.DescribeInstanceConnectEndpointsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceConnectEndpointsPages indicates an expected call of DescribeInstanceConnectEndpointsPages. -func (mr *MockEC2MockRecorder) DescribeInstanceConnectEndpointsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceConnectEndpointsPages), arg0, arg1) -} - -// DescribeInstanceConnectEndpointsPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceConnectEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 func(*ec2.DescribeInstanceConnectEndpointsOutput, 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, "DescribeInstanceConnectEndpointsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceConnectEndpointsPagesWithContext indicates an expected call of DescribeInstanceConnectEndpointsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceConnectEndpointsPagesWithContext(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, "DescribeInstanceConnectEndpointsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceConnectEndpointsPagesWithContext), varargs...) -} - -// DescribeInstanceConnectEndpointsRequest mocks base method. -func (m *MockEC2) DescribeInstanceConnectEndpointsRequest(arg0 *ec2.DescribeInstanceConnectEndpointsInput) (*request.Request, *ec2.DescribeInstanceConnectEndpointsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceConnectEndpointsOutput) - return ret0, ret1 -} - -// DescribeInstanceConnectEndpointsRequest indicates an expected call of DescribeInstanceConnectEndpointsRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceConnectEndpointsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceConnectEndpointsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceConnectEndpointsRequest), arg0) -} - -// DescribeInstanceConnectEndpointsWithContext mocks base method. -func (m *MockEC2) DescribeInstanceConnectEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceConnectEndpointsInput, arg2 ...request.Option) (*ec2.DescribeInstanceConnectEndpointsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceConnectEndpointsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceConnectEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceConnectEndpointsWithContext indicates an expected call of DescribeInstanceConnectEndpointsWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceConnectEndpointsWithContext(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, "DescribeInstanceConnectEndpointsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceConnectEndpointsWithContext), varargs...) -} - -// DescribeInstanceCreditSpecifications mocks base method. -func (m *MockEC2) DescribeInstanceCreditSpecifications(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecifications", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceCreditSpecifications indicates an expected call of DescribeInstanceCreditSpecifications. -func (mr *MockEC2MockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceCreditSpecifications), arg0) -} - -// DescribeInstanceCreditSpecificationsPages mocks base method. -func (m *MockEC2) DescribeInstanceCreditSpecificationsPages(arg0 *ec2.DescribeInstanceCreditSpecificationsInput, arg1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceCreditSpecificationsPages indicates an expected call of DescribeInstanceCreditSpecificationsPages. -func (mr *MockEC2MockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1) -} - -// DescribeInstanceCreditSpecificationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, 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, "DescribeInstanceCreditSpecificationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceCreditSpecificationsPagesWithContext indicates an expected call of DescribeInstanceCreditSpecificationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceCreditSpecificationsPagesWithContext(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, "DescribeInstanceCreditSpecificationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceCreditSpecificationsPagesWithContext), varargs...) -} - -// DescribeInstanceCreditSpecificationsRequest mocks base method. -func (m *MockEC2) DescribeInstanceCreditSpecificationsRequest(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceCreditSpecificationsOutput) - return ret0, ret1 -} - -// DescribeInstanceCreditSpecificationsRequest indicates an expected call of DescribeInstanceCreditSpecificationsRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceCreditSpecificationsRequest), arg0) -} - -// DescribeInstanceCreditSpecificationsWithContext mocks base method. -func (m *MockEC2) DescribeInstanceCreditSpecificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceCreditSpecificationsWithContext indicates an expected call of DescribeInstanceCreditSpecificationsWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceCreditSpecificationsWithContext(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, "DescribeInstanceCreditSpecificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceCreditSpecificationsWithContext), varargs...) -} - -// DescribeInstanceEventNotificationAttributes mocks base method. -func (m *MockEC2) DescribeInstanceEventNotificationAttributes(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributes", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceEventNotificationAttributes indicates an expected call of DescribeInstanceEventNotificationAttributes. -func (mr *MockEC2MockRecorder) DescribeInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventNotificationAttributes), arg0) -} - -// DescribeInstanceEventNotificationAttributesRequest mocks base method. -func (m *MockEC2) DescribeInstanceEventNotificationAttributesRequest(arg0 *ec2.DescribeInstanceEventNotificationAttributesInput) (*request.Request, *ec2.DescribeInstanceEventNotificationAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceEventNotificationAttributesOutput) - return ret0, ret1 -} - -// DescribeInstanceEventNotificationAttributesRequest indicates an expected call of DescribeInstanceEventNotificationAttributesRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventNotificationAttributesRequest), arg0) -} - -// DescribeInstanceEventNotificationAttributesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceEventNotificationAttributesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceEventNotificationAttributesWithContext indicates an expected call of DescribeInstanceEventNotificationAttributesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceEventNotificationAttributesWithContext(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, "DescribeInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventNotificationAttributesWithContext), varargs...) -} - -// DescribeInstanceEventWindows mocks base method. -func (m *MockEC2) DescribeInstanceEventWindows(arg0 *ec2.DescribeInstanceEventWindowsInput) (*ec2.DescribeInstanceEventWindowsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceEventWindows", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceEventWindows indicates an expected call of DescribeInstanceEventWindows. -func (mr *MockEC2MockRecorder) DescribeInstanceEventWindows(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindows", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventWindows), arg0) -} - -// DescribeInstanceEventWindowsPages mocks base method. -func (m *MockEC2) DescribeInstanceEventWindowsPages(arg0 *ec2.DescribeInstanceEventWindowsInput, arg1 func(*ec2.DescribeInstanceEventWindowsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceEventWindowsPages indicates an expected call of DescribeInstanceEventWindowsPages. -func (mr *MockEC2MockRecorder) DescribeInstanceEventWindowsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventWindowsPages), arg0, arg1) -} - -// DescribeInstanceEventWindowsPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceEventWindowsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 func(*ec2.DescribeInstanceEventWindowsOutput, 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, "DescribeInstanceEventWindowsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceEventWindowsPagesWithContext indicates an expected call of DescribeInstanceEventWindowsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceEventWindowsPagesWithContext(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, "DescribeInstanceEventWindowsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventWindowsPagesWithContext), varargs...) -} - -// DescribeInstanceEventWindowsRequest mocks base method. -func (m *MockEC2) DescribeInstanceEventWindowsRequest(arg0 *ec2.DescribeInstanceEventWindowsInput) (*request.Request, *ec2.DescribeInstanceEventWindowsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceEventWindowsOutput) - return ret0, ret1 -} - -// DescribeInstanceEventWindowsRequest indicates an expected call of DescribeInstanceEventWindowsRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceEventWindowsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventWindowsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventWindowsRequest), arg0) -} - -// DescribeInstanceEventWindowsWithContext mocks base method. -func (m *MockEC2) DescribeInstanceEventWindowsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceEventWindowsInput, arg2 ...request.Option) (*ec2.DescribeInstanceEventWindowsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceEventWindowsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceEventWindowsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceEventWindowsWithContext indicates an expected call of DescribeInstanceEventWindowsWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceEventWindowsWithContext(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, "DescribeInstanceEventWindowsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceEventWindowsWithContext), varargs...) -} - -// DescribeInstanceStatus mocks base method. -func (m *MockEC2) DescribeInstanceStatus(arg0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus. -func (mr *MockEC2MockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceStatus), arg0) -} - -// DescribeInstanceStatusPages mocks base method. -func (m *MockEC2) DescribeInstanceStatusPages(arg0 *ec2.DescribeInstanceStatusInput, arg1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceStatusPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceStatusPages indicates an expected call of DescribeInstanceStatusPages. -func (mr *MockEC2MockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceStatusPages), arg0, arg1) -} - -// DescribeInstanceStatusPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 func(*ec2.DescribeInstanceStatusOutput, 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, "DescribeInstanceStatusPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceStatusPagesWithContext indicates an expected call of DescribeInstanceStatusPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceStatusPagesWithContext(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, "DescribeInstanceStatusPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceStatusPagesWithContext), varargs...) -} - -// DescribeInstanceStatusRequest mocks base method. -func (m *MockEC2) DescribeInstanceStatusRequest(arg0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceStatusOutput) - return ret0, ret1 -} - -// DescribeInstanceStatusRequest indicates an expected call of DescribeInstanceStatusRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceStatusRequest), arg0) -} - -// DescribeInstanceStatusWithContext mocks base method. -func (m *MockEC2) DescribeInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceStatusWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceStatusWithContext indicates an expected call of DescribeInstanceStatusWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceStatusWithContext(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, "DescribeInstanceStatusWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceStatusWithContext), varargs...) -} - -// DescribeInstanceTopology mocks base method. -func (m *MockEC2) DescribeInstanceTopology(arg0 *ec2.DescribeInstanceTopologyInput) (*ec2.DescribeInstanceTopologyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTopology", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTopology indicates an expected call of DescribeInstanceTopology. -func (mr *MockEC2MockRecorder) DescribeInstanceTopology(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopology", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTopology), arg0) -} - -// DescribeInstanceTopologyPages mocks base method. -func (m *MockEC2) DescribeInstanceTopologyPages(arg0 *ec2.DescribeInstanceTopologyInput, arg1 func(*ec2.DescribeInstanceTopologyOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTopologyPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTopologyPages indicates an expected call of DescribeInstanceTopologyPages. -func (mr *MockEC2MockRecorder) DescribeInstanceTopologyPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTopologyPages), arg0, arg1) -} - -// DescribeInstanceTopologyPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTopologyPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 func(*ec2.DescribeInstanceTopologyOutput, 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, "DescribeInstanceTopologyPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTopologyPagesWithContext indicates an expected call of DescribeInstanceTopologyPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTopologyPagesWithContext(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, "DescribeInstanceTopologyPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTopologyPagesWithContext), varargs...) -} - -// DescribeInstanceTopologyRequest mocks base method. -func (m *MockEC2) DescribeInstanceTopologyRequest(arg0 *ec2.DescribeInstanceTopologyInput) (*request.Request, *ec2.DescribeInstanceTopologyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTopologyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceTopologyOutput) - return ret0, ret1 -} - -// DescribeInstanceTopologyRequest indicates an expected call of DescribeInstanceTopologyRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceTopologyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTopologyRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTopologyRequest), arg0) -} - -// DescribeInstanceTopologyWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTopologyWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTopologyInput, arg2 ...request.Option) (*ec2.DescribeInstanceTopologyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceTopologyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceTopologyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTopologyWithContext indicates an expected call of DescribeInstanceTopologyWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTopologyWithContext(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, "DescribeInstanceTopologyWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTopologyWithContext), varargs...) -} - -// DescribeInstanceTypeOfferings mocks base method. -func (m *MockEC2) DescribeInstanceTypeOfferings(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*ec2.DescribeInstanceTypeOfferingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferings", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTypeOfferings indicates an expected call of DescribeInstanceTypeOfferings. -func (mr *MockEC2MockRecorder) DescribeInstanceTypeOfferings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferings", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypeOfferings), arg0) -} - -// DescribeInstanceTypeOfferingsPages mocks base method. -func (m *MockEC2) DescribeInstanceTypeOfferingsPages(arg0 *ec2.DescribeInstanceTypeOfferingsInput, arg1 func(*ec2.DescribeInstanceTypeOfferingsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTypeOfferingsPages indicates an expected call of DescribeInstanceTypeOfferingsPages. -func (mr *MockEC2MockRecorder) DescribeInstanceTypeOfferingsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypeOfferingsPages), arg0, arg1) -} - -// DescribeInstanceTypeOfferingsPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTypeOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 func(*ec2.DescribeInstanceTypeOfferingsOutput, 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, "DescribeInstanceTypeOfferingsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTypeOfferingsPagesWithContext indicates an expected call of DescribeInstanceTypeOfferingsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTypeOfferingsPagesWithContext(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, "DescribeInstanceTypeOfferingsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypeOfferingsPagesWithContext), varargs...) -} - -// DescribeInstanceTypeOfferingsRequest mocks base method. -func (m *MockEC2) DescribeInstanceTypeOfferingsRequest(arg0 *ec2.DescribeInstanceTypeOfferingsInput) (*request.Request, *ec2.DescribeInstanceTypeOfferingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceTypeOfferingsOutput) - return ret0, ret1 -} - -// DescribeInstanceTypeOfferingsRequest indicates an expected call of DescribeInstanceTypeOfferingsRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceTypeOfferingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypeOfferingsRequest), arg0) -} - -// DescribeInstanceTypeOfferingsWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTypeOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypeOfferingsInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypeOfferingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceTypeOfferingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceTypeOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTypeOfferingsWithContext indicates an expected call of DescribeInstanceTypeOfferingsWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTypeOfferingsWithContext(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, "DescribeInstanceTypeOfferingsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypeOfferingsWithContext), varargs...) -} - -// DescribeInstanceTypes mocks base method. -func (m *MockEC2) DescribeInstanceTypes(arg0 *ec2.DescribeInstanceTypesInput) (*ec2.DescribeInstanceTypesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypes", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTypes indicates an expected call of DescribeInstanceTypes. -func (mr *MockEC2MockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypes), arg0) -} - -// DescribeInstanceTypesPages mocks base method. -func (m *MockEC2) DescribeInstanceTypesPages(arg0 *ec2.DescribeInstanceTypesInput, arg1 func(*ec2.DescribeInstanceTypesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTypesPages indicates an expected call of DescribeInstanceTypesPages. -func (mr *MockEC2MockRecorder) DescribeInstanceTypesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypesPages), arg0, arg1) -} - -// DescribeInstanceTypesPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 func(*ec2.DescribeInstanceTypesOutput, 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, "DescribeInstanceTypesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstanceTypesPagesWithContext indicates an expected call of DescribeInstanceTypesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTypesPagesWithContext(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, "DescribeInstanceTypesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypesPagesWithContext), varargs...) -} - -// DescribeInstanceTypesRequest mocks base method. -func (m *MockEC2) DescribeInstanceTypesRequest(arg0 *ec2.DescribeInstanceTypesInput) (*request.Request, *ec2.DescribeInstanceTypesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstanceTypesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstanceTypesOutput) - return ret0, ret1 -} - -// DescribeInstanceTypesRequest indicates an expected call of DescribeInstanceTypesRequest. -func (mr *MockEC2MockRecorder) DescribeInstanceTypesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypesRequest), arg0) -} - -// DescribeInstanceTypesWithContext mocks base method. -func (m *MockEC2) DescribeInstanceTypesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceTypesInput, arg2 ...request.Option) (*ec2.DescribeInstanceTypesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstanceTypesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstanceTypesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstanceTypesWithContext indicates an expected call of DescribeInstanceTypesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstanceTypesWithContext(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, "DescribeInstanceTypesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstanceTypesWithContext), varargs...) -} - -// DescribeInstances mocks base method. -func (m *MockEC2) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstances indicates an expected call of DescribeInstances. -func (mr *MockEC2MockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2)(nil).DescribeInstances), arg0) -} - -// DescribeInstancesAsList mocks base method. -func (m *MockEC2) DescribeInstancesAsList(arg0 context.Context, arg1 *ec2.DescribeInstancesInput) ([]*ec2.Instance, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancesAsList", arg0, arg1) - ret0, _ := ret[0].([]*ec2.Instance) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancesAsList indicates an expected call of DescribeInstancesAsList. -func (mr *MockEC2MockRecorder) DescribeInstancesAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesAsList", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesAsList), arg0, arg1) -} - -// DescribeInstancesPages mocks base method. -func (m *MockEC2) DescribeInstancesPages(arg0 *ec2.DescribeInstancesInput, arg1 func(*ec2.DescribeInstancesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancesPages indicates an expected call of DescribeInstancesPages. -func (mr *MockEC2MockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesPages), arg0, arg1) -} - -// DescribeInstancesPagesWithContext mocks base method. -func (m *MockEC2) DescribeInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 func(*ec2.DescribeInstancesOutput, 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, "DescribeInstancesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInstancesPagesWithContext indicates an expected call of DescribeInstancesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstancesPagesWithContext(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, "DescribeInstancesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesPagesWithContext), varargs...) -} - -// DescribeInstancesRequest mocks base method. -func (m *MockEC2) DescribeInstancesRequest(arg0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInstancesOutput) - return ret0, ret1 -} - -// DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesRequest), arg0) -} - -// DescribeInstancesWithContext mocks base method. -func (m *MockEC2) DescribeInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeInstancesWithContext(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, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInstancesWithContext), varargs...) -} - -// DescribeInternetGateways mocks base method. -func (m *MockEC2) DescribeInternetGateways(arg0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInternetGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInternetGateways indicates an expected call of DescribeInternetGateways. -func (mr *MockEC2MockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2)(nil).DescribeInternetGateways), arg0) -} - -// DescribeInternetGatewaysPages mocks base method. -func (m *MockEC2) DescribeInternetGatewaysPages(arg0 *ec2.DescribeInternetGatewaysInput, arg1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInternetGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInternetGatewaysPages indicates an expected call of DescribeInternetGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeInternetGatewaysPages), arg0, arg1) -} - -// DescribeInternetGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeInternetGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 func(*ec2.DescribeInternetGatewaysOutput, 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, "DescribeInternetGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeInternetGatewaysPagesWithContext indicates an expected call of DescribeInternetGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeInternetGatewaysPagesWithContext(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, "DescribeInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInternetGatewaysPagesWithContext), varargs...) -} - -// DescribeInternetGatewaysRequest mocks base method. -func (m *MockEC2) DescribeInternetGatewaysRequest(arg0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeInternetGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeInternetGatewaysOutput) - return ret0, ret1 -} - -// DescribeInternetGatewaysRequest indicates an expected call of DescribeInternetGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeInternetGatewaysRequest), arg0) -} - -// DescribeInternetGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeInternetGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeInternetGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeInternetGatewaysWithContext indicates an expected call of DescribeInternetGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeInternetGatewaysWithContext(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, "DescribeInternetGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeInternetGatewaysWithContext), varargs...) -} - -// DescribeIpamByoasn mocks base method. -func (m *MockEC2) DescribeIpamByoasn(arg0 *ec2.DescribeIpamByoasnInput) (*ec2.DescribeIpamByoasnOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamByoasn", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamByoasn indicates an expected call of DescribeIpamByoasn. -func (mr *MockEC2MockRecorder) DescribeIpamByoasn(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasn", reflect.TypeOf((*MockEC2)(nil).DescribeIpamByoasn), arg0) -} - -// DescribeIpamByoasnRequest mocks base method. -func (m *MockEC2) DescribeIpamByoasnRequest(arg0 *ec2.DescribeIpamByoasnInput) (*request.Request, *ec2.DescribeIpamByoasnOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamByoasnRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamByoasnOutput) - return ret0, ret1 -} - -// DescribeIpamByoasnRequest indicates an expected call of DescribeIpamByoasnRequest. -func (mr *MockEC2MockRecorder) DescribeIpamByoasnRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamByoasnRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamByoasnRequest), arg0) -} - -// DescribeIpamByoasnWithContext mocks base method. -func (m *MockEC2) DescribeIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamByoasnInput, arg2 ...request.Option) (*ec2.DescribeIpamByoasnOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamByoasnWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamByoasnWithContext indicates an expected call of DescribeIpamByoasnWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamByoasnWithContext(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, "DescribeIpamByoasnWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamByoasnWithContext), varargs...) -} - -// DescribeIpamPools mocks base method. -func (m *MockEC2) DescribeIpamPools(arg0 *ec2.DescribeIpamPoolsInput) (*ec2.DescribeIpamPoolsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamPools", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamPools indicates an expected call of DescribeIpamPools. -func (mr *MockEC2MockRecorder) DescribeIpamPools(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPools", reflect.TypeOf((*MockEC2)(nil).DescribeIpamPools), arg0) -} - -// DescribeIpamPoolsPages mocks base method. -func (m *MockEC2) DescribeIpamPoolsPages(arg0 *ec2.DescribeIpamPoolsInput, arg1 func(*ec2.DescribeIpamPoolsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamPoolsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamPoolsPages indicates an expected call of DescribeIpamPoolsPages. -func (mr *MockEC2MockRecorder) DescribeIpamPoolsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpamPoolsPages), arg0, arg1) -} - -// DescribeIpamPoolsPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpamPoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 func(*ec2.DescribeIpamPoolsOutput, 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, "DescribeIpamPoolsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamPoolsPagesWithContext indicates an expected call of DescribeIpamPoolsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamPoolsPagesWithContext(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, "DescribeIpamPoolsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamPoolsPagesWithContext), varargs...) -} - -// DescribeIpamPoolsRequest mocks base method. -func (m *MockEC2) DescribeIpamPoolsRequest(arg0 *ec2.DescribeIpamPoolsInput) (*request.Request, *ec2.DescribeIpamPoolsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamPoolsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamPoolsOutput) - return ret0, ret1 -} - -// DescribeIpamPoolsRequest indicates an expected call of DescribeIpamPoolsRequest. -func (mr *MockEC2MockRecorder) DescribeIpamPoolsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamPoolsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamPoolsRequest), arg0) -} - -// DescribeIpamPoolsWithContext mocks base method. -func (m *MockEC2) DescribeIpamPoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamPoolsInput, arg2 ...request.Option) (*ec2.DescribeIpamPoolsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamPoolsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamPoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamPoolsWithContext indicates an expected call of DescribeIpamPoolsWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamPoolsWithContext(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, "DescribeIpamPoolsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamPoolsWithContext), varargs...) -} - -// DescribeIpamResourceDiscoveries mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveries(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveries", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveries indicates an expected call of DescribeIpamResourceDiscoveries. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveries", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveries), arg0) -} - -// DescribeIpamResourceDiscoveriesPages mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveriesPages(arg0 *ec2.DescribeIpamResourceDiscoveriesInput, arg1 func(*ec2.DescribeIpamResourceDiscoveriesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamResourceDiscoveriesPages indicates an expected call of DescribeIpamResourceDiscoveriesPages. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveriesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveriesPages), arg0, arg1) -} - -// DescribeIpamResourceDiscoveriesPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveriesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 func(*ec2.DescribeIpamResourceDiscoveriesOutput, 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, "DescribeIpamResourceDiscoveriesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamResourceDiscoveriesPagesWithContext indicates an expected call of DescribeIpamResourceDiscoveriesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveriesPagesWithContext(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, "DescribeIpamResourceDiscoveriesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveriesPagesWithContext), varargs...) -} - -// DescribeIpamResourceDiscoveriesRequest mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveriesRequest(arg0 *ec2.DescribeIpamResourceDiscoveriesInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveriesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveriesOutput) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveriesRequest indicates an expected call of DescribeIpamResourceDiscoveriesRequest. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveriesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveriesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveriesRequest), arg0) -} - -// DescribeIpamResourceDiscoveriesWithContext mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveriesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveriesInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveriesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveriesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveriesWithContext indicates an expected call of DescribeIpamResourceDiscoveriesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveriesWithContext(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, "DescribeIpamResourceDiscoveriesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveriesWithContext), varargs...) -} - -// DescribeIpamResourceDiscoveryAssociations mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveryAssociations(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociations", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveryAssociations indicates an expected call of DescribeIpamResourceDiscoveryAssociations. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveryAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociations", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveryAssociations), arg0) -} - -// DescribeIpamResourceDiscoveryAssociationsPages mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveryAssociationsPages(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg1 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamResourceDiscoveryAssociationsPages indicates an expected call of DescribeIpamResourceDiscoveryAssociationsPages. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveryAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveryAssociationsPages), arg0, arg1) -} - -// DescribeIpamResourceDiscoveryAssociationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveryAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 func(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, 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, "DescribeIpamResourceDiscoveryAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamResourceDiscoveryAssociationsPagesWithContext indicates an expected call of DescribeIpamResourceDiscoveryAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveryAssociationsPagesWithContext(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, "DescribeIpamResourceDiscoveryAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveryAssociationsPagesWithContext), varargs...) -} - -// DescribeIpamResourceDiscoveryAssociationsRequest mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 *ec2.DescribeIpamResourceDiscoveryAssociationsInput) (*request.Request, *ec2.DescribeIpamResourceDiscoveryAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveryAssociationsRequest indicates an expected call of DescribeIpamResourceDiscoveryAssociationsRequest. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveryAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamResourceDiscoveryAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveryAssociationsRequest), arg0) -} - -// DescribeIpamResourceDiscoveryAssociationsWithContext mocks base method. -func (m *MockEC2) DescribeIpamResourceDiscoveryAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamResourceDiscoveryAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIpamResourceDiscoveryAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamResourceDiscoveryAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamResourceDiscoveryAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamResourceDiscoveryAssociationsWithContext indicates an expected call of DescribeIpamResourceDiscoveryAssociationsWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamResourceDiscoveryAssociationsWithContext(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, "DescribeIpamResourceDiscoveryAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamResourceDiscoveryAssociationsWithContext), varargs...) -} - -// DescribeIpamScopes mocks base method. -func (m *MockEC2) DescribeIpamScopes(arg0 *ec2.DescribeIpamScopesInput) (*ec2.DescribeIpamScopesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamScopes", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamScopes indicates an expected call of DescribeIpamScopes. -func (mr *MockEC2MockRecorder) DescribeIpamScopes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopes", reflect.TypeOf((*MockEC2)(nil).DescribeIpamScopes), arg0) -} - -// DescribeIpamScopesPages mocks base method. -func (m *MockEC2) DescribeIpamScopesPages(arg0 *ec2.DescribeIpamScopesInput, arg1 func(*ec2.DescribeIpamScopesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamScopesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamScopesPages indicates an expected call of DescribeIpamScopesPages. -func (mr *MockEC2MockRecorder) DescribeIpamScopesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpamScopesPages), arg0, arg1) -} - -// DescribeIpamScopesPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpamScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 func(*ec2.DescribeIpamScopesOutput, 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, "DescribeIpamScopesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamScopesPagesWithContext indicates an expected call of DescribeIpamScopesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamScopesPagesWithContext(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, "DescribeIpamScopesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamScopesPagesWithContext), varargs...) -} - -// DescribeIpamScopesRequest mocks base method. -func (m *MockEC2) DescribeIpamScopesRequest(arg0 *ec2.DescribeIpamScopesInput) (*request.Request, *ec2.DescribeIpamScopesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamScopesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamScopesOutput) - return ret0, ret1 -} - -// DescribeIpamScopesRequest indicates an expected call of DescribeIpamScopesRequest. -func (mr *MockEC2MockRecorder) DescribeIpamScopesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamScopesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamScopesRequest), arg0) -} - -// DescribeIpamScopesWithContext mocks base method. -func (m *MockEC2) DescribeIpamScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamScopesInput, arg2 ...request.Option) (*ec2.DescribeIpamScopesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamScopesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamScopesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamScopesWithContext indicates an expected call of DescribeIpamScopesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamScopesWithContext(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, "DescribeIpamScopesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamScopesWithContext), varargs...) -} - -// DescribeIpams mocks base method. -func (m *MockEC2) DescribeIpams(arg0 *ec2.DescribeIpamsInput) (*ec2.DescribeIpamsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpams", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpamsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpams indicates an expected call of DescribeIpams. -func (mr *MockEC2MockRecorder) DescribeIpams(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpams", reflect.TypeOf((*MockEC2)(nil).DescribeIpams), arg0) -} - -// DescribeIpamsPages mocks base method. -func (m *MockEC2) DescribeIpamsPages(arg0 *ec2.DescribeIpamsInput, arg1 func(*ec2.DescribeIpamsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamsPages indicates an expected call of DescribeIpamsPages. -func (mr *MockEC2MockRecorder) DescribeIpamsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpamsPages), arg0, arg1) -} - -// DescribeIpamsPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpamsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 func(*ec2.DescribeIpamsOutput, 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, "DescribeIpamsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpamsPagesWithContext indicates an expected call of DescribeIpamsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamsPagesWithContext(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, "DescribeIpamsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamsPagesWithContext), varargs...) -} - -// DescribeIpamsRequest mocks base method. -func (m *MockEC2) DescribeIpamsRequest(arg0 *ec2.DescribeIpamsInput) (*request.Request, *ec2.DescribeIpamsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpamsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpamsOutput) - return ret0, ret1 -} - -// DescribeIpamsRequest indicates an expected call of DescribeIpamsRequest. -func (mr *MockEC2MockRecorder) DescribeIpamsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpamsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpamsRequest), arg0) -} - -// DescribeIpamsWithContext mocks base method. -func (m *MockEC2) DescribeIpamsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpamsInput, arg2 ...request.Option) (*ec2.DescribeIpamsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpamsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpamsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpamsWithContext indicates an expected call of DescribeIpamsWithContext. -func (mr *MockEC2MockRecorder) DescribeIpamsWithContext(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, "DescribeIpamsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpamsWithContext), varargs...) -} - -// DescribeIpv6Pools mocks base method. -func (m *MockEC2) DescribeIpv6Pools(arg0 *ec2.DescribeIpv6PoolsInput) (*ec2.DescribeIpv6PoolsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpv6Pools", arg0) - ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpv6Pools indicates an expected call of DescribeIpv6Pools. -func (mr *MockEC2MockRecorder) DescribeIpv6Pools(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6Pools", reflect.TypeOf((*MockEC2)(nil).DescribeIpv6Pools), arg0) -} - -// DescribeIpv6PoolsPages mocks base method. -func (m *MockEC2) DescribeIpv6PoolsPages(arg0 *ec2.DescribeIpv6PoolsInput, arg1 func(*ec2.DescribeIpv6PoolsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpv6PoolsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpv6PoolsPages indicates an expected call of DescribeIpv6PoolsPages. -func (mr *MockEC2MockRecorder) DescribeIpv6PoolsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPages", reflect.TypeOf((*MockEC2)(nil).DescribeIpv6PoolsPages), arg0, arg1) -} - -// DescribeIpv6PoolsPagesWithContext mocks base method. -func (m *MockEC2) DescribeIpv6PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 func(*ec2.DescribeIpv6PoolsOutput, 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, "DescribeIpv6PoolsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeIpv6PoolsPagesWithContext indicates an expected call of DescribeIpv6PoolsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeIpv6PoolsPagesWithContext(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, "DescribeIpv6PoolsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpv6PoolsPagesWithContext), varargs...) -} - -// DescribeIpv6PoolsRequest mocks base method. -func (m *MockEC2) DescribeIpv6PoolsRequest(arg0 *ec2.DescribeIpv6PoolsInput) (*request.Request, *ec2.DescribeIpv6PoolsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeIpv6PoolsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeIpv6PoolsOutput) - return ret0, ret1 -} - -// DescribeIpv6PoolsRequest indicates an expected call of DescribeIpv6PoolsRequest. -func (mr *MockEC2MockRecorder) DescribeIpv6PoolsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeIpv6PoolsRequest), arg0) -} - -// DescribeIpv6PoolsWithContext mocks base method. -func (m *MockEC2) DescribeIpv6PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribeIpv6PoolsInput, arg2 ...request.Option) (*ec2.DescribeIpv6PoolsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeIpv6PoolsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeIpv6PoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeIpv6PoolsWithContext indicates an expected call of DescribeIpv6PoolsWithContext. -func (mr *MockEC2MockRecorder) DescribeIpv6PoolsWithContext(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, "DescribeIpv6PoolsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeIpv6PoolsWithContext), varargs...) -} - -// DescribeKeyPairs mocks base method. -func (m *MockEC2) DescribeKeyPairs(arg0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeKeyPairs", arg0) - ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeKeyPairs indicates an expected call of DescribeKeyPairs. -func (mr *MockEC2MockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2)(nil).DescribeKeyPairs), arg0) -} - -// DescribeKeyPairsRequest mocks base method. -func (m *MockEC2) DescribeKeyPairsRequest(arg0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeKeyPairsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeKeyPairsOutput) - return ret0, ret1 -} - -// DescribeKeyPairsRequest indicates an expected call of DescribeKeyPairsRequest. -func (mr *MockEC2MockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeKeyPairsRequest), arg0) -} - -// DescribeKeyPairsWithContext mocks base method. -func (m *MockEC2) DescribeKeyPairsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.Option) (*ec2.DescribeKeyPairsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeKeyPairsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeKeyPairsWithContext indicates an expected call of DescribeKeyPairsWithContext. -func (mr *MockEC2MockRecorder) DescribeKeyPairsWithContext(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, "DescribeKeyPairsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeKeyPairsWithContext), varargs...) -} - -// DescribeLaunchTemplateVersions mocks base method. -func (m *MockEC2) DescribeLaunchTemplateVersions(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", arg0) - ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplateVersions), arg0) -} - -// DescribeLaunchTemplateVersionsPages mocks base method. -func (m *MockEC2) DescribeLaunchTemplateVersionsPages(arg0 *ec2.DescribeLaunchTemplateVersionsInput, arg1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLaunchTemplateVersionsPages indicates an expected call of DescribeLaunchTemplateVersionsPages. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1) -} - -// DescribeLaunchTemplateVersionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeLaunchTemplateVersionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 func(*ec2.DescribeLaunchTemplateVersionsOutput, 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, "DescribeLaunchTemplateVersionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLaunchTemplateVersionsPagesWithContext indicates an expected call of DescribeLaunchTemplateVersionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplateVersionsPagesWithContext(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, "DescribeLaunchTemplateVersionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplateVersionsPagesWithContext), varargs...) -} - -// DescribeLaunchTemplateVersionsRequest mocks base method. -func (m *MockEC2) DescribeLaunchTemplateVersionsRequest(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLaunchTemplateVersionsOutput) - return ret0, ret1 -} - -// DescribeLaunchTemplateVersionsRequest indicates an expected call of DescribeLaunchTemplateVersionsRequest. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplateVersionsRequest), arg0) -} - -// DescribeLaunchTemplateVersionsWithContext mocks base method. -func (m *MockEC2) DescribeLaunchTemplateVersionsWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLaunchTemplateVersionsWithContext indicates an expected call of DescribeLaunchTemplateVersionsWithContext. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplateVersionsWithContext(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, "DescribeLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplateVersionsWithContext), varargs...) -} - -// DescribeLaunchTemplates mocks base method. -func (m *MockEC2) DescribeLaunchTemplates(arg0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplates", arg0) - ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLaunchTemplates indicates an expected call of DescribeLaunchTemplates. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplates), arg0) -} - -// DescribeLaunchTemplatesPages mocks base method. -func (m *MockEC2) DescribeLaunchTemplatesPages(arg0 *ec2.DescribeLaunchTemplatesInput, arg1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLaunchTemplatesPages indicates an expected call of DescribeLaunchTemplatesPages. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplatesPages), arg0, arg1) -} - -// DescribeLaunchTemplatesPagesWithContext mocks base method. -func (m *MockEC2) DescribeLaunchTemplatesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 func(*ec2.DescribeLaunchTemplatesOutput, 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, "DescribeLaunchTemplatesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLaunchTemplatesPagesWithContext indicates an expected call of DescribeLaunchTemplatesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplatesPagesWithContext(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, "DescribeLaunchTemplatesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplatesPagesWithContext), varargs...) -} - -// DescribeLaunchTemplatesRequest mocks base method. -func (m *MockEC2) DescribeLaunchTemplatesRequest(arg0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLaunchTemplatesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLaunchTemplatesOutput) - return ret0, ret1 -} - -// DescribeLaunchTemplatesRequest indicates an expected call of DescribeLaunchTemplatesRequest. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplatesRequest), arg0) -} - -// DescribeLaunchTemplatesWithContext mocks base method. -func (m *MockEC2) DescribeLaunchTemplatesWithContext(arg0 context.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLaunchTemplatesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLaunchTemplatesWithContext indicates an expected call of DescribeLaunchTemplatesWithContext. -func (mr *MockEC2MockRecorder) DescribeLaunchTemplatesWithContext(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, "DescribeLaunchTemplatesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLaunchTemplatesWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations), arg0) -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages), arg0, arg1) -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, 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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest), arg0) -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(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, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTableVpcAssociations mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVpcAssociations(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociations", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVpcAssociations indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociations. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVpcAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociations", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVpcAssociations), arg0) -} - -// DescribeLocalGatewayRouteTableVpcAssociationsPages mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg1 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTableVpcAssociationsPages indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPages), arg0, arg1) -} - -// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 func(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, 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, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(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, "DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTableVpcAssociationsRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVpcAssociationsRequest indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVpcAssociationsRequest), arg0) -} - -// DescribeLocalGatewayRouteTableVpcAssociationsWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTableVpcAssociationsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTableVpcAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTableVpcAssociationsWithContext indicates an expected call of DescribeLocalGatewayRouteTableVpcAssociationsWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(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, "DescribeLocalGatewayRouteTableVpcAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTableVpcAssociationsWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTables mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTables(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTables", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTables indicates an expected call of DescribeLocalGatewayRouteTables. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTables(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTables", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTables), arg0) -} - -// DescribeLocalGatewayRouteTablesPages mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTablesPages(arg0 *ec2.DescribeLocalGatewayRouteTablesInput, arg1 func(*ec2.DescribeLocalGatewayRouteTablesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTablesPages indicates an expected call of DescribeLocalGatewayRouteTablesPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTablesPages), arg0, arg1) -} - -// DescribeLocalGatewayRouteTablesPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 func(*ec2.DescribeLocalGatewayRouteTablesOutput, 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, "DescribeLocalGatewayRouteTablesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayRouteTablesPagesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTablesPagesWithContext(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, "DescribeLocalGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTablesPagesWithContext), varargs...) -} - -// DescribeLocalGatewayRouteTablesRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTablesRequest(arg0 *ec2.DescribeLocalGatewayRouteTablesInput) (*request.Request, *ec2.DescribeLocalGatewayRouteTablesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewayRouteTablesOutput) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTablesRequest indicates an expected call of DescribeLocalGatewayRouteTablesRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTablesRequest), arg0) -} - -// DescribeLocalGatewayRouteTablesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayRouteTablesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewayRouteTablesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayRouteTablesWithContext indicates an expected call of DescribeLocalGatewayRouteTablesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayRouteTablesWithContext(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, "DescribeLocalGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayRouteTablesWithContext), varargs...) -} - -// DescribeLocalGatewayVirtualInterfaceGroups mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaceGroups(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroups", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfaceGroups indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroups. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaceGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroups", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaceGroups), arg0) -} - -// DescribeLocalGatewayVirtualInterfaceGroupsPages mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayVirtualInterfaceGroupsPages indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPages), arg0, arg1) -} - -// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, 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, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(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, "DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext), varargs...) -} - -// DescribeLocalGatewayVirtualInterfaceGroupsRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfaceGroupsRequest indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaceGroupsRequest), arg0) -} - -// DescribeLocalGatewayVirtualInterfaceGroupsWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfaceGroupsInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfaceGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfaceGroupsWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfaceGroupsWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(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, "DescribeLocalGatewayVirtualInterfaceGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaceGroupsWithContext), varargs...) -} - -// DescribeLocalGatewayVirtualInterfaces mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfaces(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfaces", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfaces indicates an expected call of DescribeLocalGatewayVirtualInterfaces. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfaces(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaces", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfaces), arg0) -} - -// DescribeLocalGatewayVirtualInterfacesPages mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfacesPages(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg1 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayVirtualInterfacesPages indicates an expected call of DescribeLocalGatewayVirtualInterfacesPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfacesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfacesPages), arg0, arg1) -} - -// DescribeLocalGatewayVirtualInterfacesPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 func(*ec2.DescribeLocalGatewayVirtualInterfacesOutput, 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, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewayVirtualInterfacesPagesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfacesPagesWithContext(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, "DescribeLocalGatewayVirtualInterfacesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfacesPagesWithContext), varargs...) -} - -// DescribeLocalGatewayVirtualInterfacesRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfacesRequest(arg0 *ec2.DescribeLocalGatewayVirtualInterfacesInput) (*request.Request, *ec2.DescribeLocalGatewayVirtualInterfacesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfacesRequest indicates an expected call of DescribeLocalGatewayVirtualInterfacesRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfacesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfacesRequest), arg0) -} - -// DescribeLocalGatewayVirtualInterfacesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewayVirtualInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewayVirtualInterfacesInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewayVirtualInterfacesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewayVirtualInterfacesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewayVirtualInterfacesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewayVirtualInterfacesWithContext indicates an expected call of DescribeLocalGatewayVirtualInterfacesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewayVirtualInterfacesWithContext(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, "DescribeLocalGatewayVirtualInterfacesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewayVirtualInterfacesWithContext), varargs...) -} - -// DescribeLocalGateways mocks base method. -func (m *MockEC2) DescribeLocalGateways(arg0 *ec2.DescribeLocalGatewaysInput) (*ec2.DescribeLocalGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGateways indicates an expected call of DescribeLocalGateways. -func (mr *MockEC2MockRecorder) DescribeLocalGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGateways", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGateways), arg0) -} - -// DescribeLocalGatewaysPages mocks base method. -func (m *MockEC2) DescribeLocalGatewaysPages(arg0 *ec2.DescribeLocalGatewaysInput, arg1 func(*ec2.DescribeLocalGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewaysPages indicates an expected call of DescribeLocalGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeLocalGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewaysPages), arg0, arg1) -} - -// DescribeLocalGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 func(*ec2.DescribeLocalGatewaysOutput, 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, "DescribeLocalGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLocalGatewaysPagesWithContext indicates an expected call of DescribeLocalGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewaysPagesWithContext(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, "DescribeLocalGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewaysPagesWithContext), varargs...) -} - -// DescribeLocalGatewaysRequest mocks base method. -func (m *MockEC2) DescribeLocalGatewaysRequest(arg0 *ec2.DescribeLocalGatewaysInput) (*request.Request, *ec2.DescribeLocalGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLocalGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLocalGatewaysOutput) - return ret0, ret1 -} - -// DescribeLocalGatewaysRequest indicates an expected call of DescribeLocalGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeLocalGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewaysRequest), arg0) -} - -// DescribeLocalGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeLocalGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeLocalGatewaysInput, arg2 ...request.Option) (*ec2.DescribeLocalGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLocalGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLocalGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLocalGatewaysWithContext indicates an expected call of DescribeLocalGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeLocalGatewaysWithContext(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, "DescribeLocalGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLocalGatewaysWithContext), varargs...) -} - -// DescribeLockedSnapshots mocks base method. -func (m *MockEC2) DescribeLockedSnapshots(arg0 *ec2.DescribeLockedSnapshotsInput) (*ec2.DescribeLockedSnapshotsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLockedSnapshots", arg0) - ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLockedSnapshots indicates an expected call of DescribeLockedSnapshots. -func (mr *MockEC2MockRecorder) DescribeLockedSnapshots(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshots", reflect.TypeOf((*MockEC2)(nil).DescribeLockedSnapshots), arg0) -} - -// DescribeLockedSnapshotsRequest mocks base method. -func (m *MockEC2) DescribeLockedSnapshotsRequest(arg0 *ec2.DescribeLockedSnapshotsInput) (*request.Request, *ec2.DescribeLockedSnapshotsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLockedSnapshotsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeLockedSnapshotsOutput) - return ret0, ret1 -} - -// DescribeLockedSnapshotsRequest indicates an expected call of DescribeLockedSnapshotsRequest. -func (mr *MockEC2MockRecorder) DescribeLockedSnapshotsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLockedSnapshotsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeLockedSnapshotsRequest), arg0) -} - -// DescribeLockedSnapshotsWithContext mocks base method. -func (m *MockEC2) DescribeLockedSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeLockedSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeLockedSnapshotsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLockedSnapshotsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeLockedSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLockedSnapshotsWithContext indicates an expected call of DescribeLockedSnapshotsWithContext. -func (mr *MockEC2MockRecorder) DescribeLockedSnapshotsWithContext(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, "DescribeLockedSnapshotsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeLockedSnapshotsWithContext), varargs...) -} - -// DescribeManagedPrefixLists mocks base method. -func (m *MockEC2) DescribeManagedPrefixLists(arg0 *ec2.DescribeManagedPrefixListsInput) (*ec2.DescribeManagedPrefixListsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeManagedPrefixLists", arg0) - ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeManagedPrefixLists indicates an expected call of DescribeManagedPrefixLists. -func (mr *MockEC2MockRecorder) DescribeManagedPrefixLists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixLists", reflect.TypeOf((*MockEC2)(nil).DescribeManagedPrefixLists), arg0) -} - -// DescribeManagedPrefixListsPages mocks base method. -func (m *MockEC2) DescribeManagedPrefixListsPages(arg0 *ec2.DescribeManagedPrefixListsInput, arg1 func(*ec2.DescribeManagedPrefixListsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeManagedPrefixListsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeManagedPrefixListsPages indicates an expected call of DescribeManagedPrefixListsPages. -func (mr *MockEC2MockRecorder) DescribeManagedPrefixListsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsPages", reflect.TypeOf((*MockEC2)(nil).DescribeManagedPrefixListsPages), arg0, arg1) -} - -// DescribeManagedPrefixListsPagesWithContext mocks base method. -func (m *MockEC2) DescribeManagedPrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 func(*ec2.DescribeManagedPrefixListsOutput, 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, "DescribeManagedPrefixListsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeManagedPrefixListsPagesWithContext indicates an expected call of DescribeManagedPrefixListsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeManagedPrefixListsPagesWithContext(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, "DescribeManagedPrefixListsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeManagedPrefixListsPagesWithContext), varargs...) -} - -// DescribeManagedPrefixListsRequest mocks base method. -func (m *MockEC2) DescribeManagedPrefixListsRequest(arg0 *ec2.DescribeManagedPrefixListsInput) (*request.Request, *ec2.DescribeManagedPrefixListsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeManagedPrefixListsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeManagedPrefixListsOutput) - return ret0, ret1 -} - -// DescribeManagedPrefixListsRequest indicates an expected call of DescribeManagedPrefixListsRequest. -func (mr *MockEC2MockRecorder) DescribeManagedPrefixListsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeManagedPrefixListsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeManagedPrefixListsRequest), arg0) -} - -// DescribeManagedPrefixListsWithContext mocks base method. -func (m *MockEC2) DescribeManagedPrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribeManagedPrefixListsInput, arg2 ...request.Option) (*ec2.DescribeManagedPrefixListsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeManagedPrefixListsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeManagedPrefixListsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeManagedPrefixListsWithContext indicates an expected call of DescribeManagedPrefixListsWithContext. -func (mr *MockEC2MockRecorder) DescribeManagedPrefixListsWithContext(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, "DescribeManagedPrefixListsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeManagedPrefixListsWithContext), varargs...) -} - -// DescribeMovingAddresses mocks base method. -func (m *MockEC2) DescribeMovingAddresses(arg0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMovingAddresses", arg0) - ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMovingAddresses indicates an expected call of DescribeMovingAddresses. -func (mr *MockEC2MockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2)(nil).DescribeMovingAddresses), arg0) -} - -// DescribeMovingAddressesPages mocks base method. -func (m *MockEC2) DescribeMovingAddressesPages(arg0 *ec2.DescribeMovingAddressesInput, arg1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMovingAddressesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMovingAddressesPages indicates an expected call of DescribeMovingAddressesPages. -func (mr *MockEC2MockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2)(nil).DescribeMovingAddressesPages), arg0, arg1) -} - -// DescribeMovingAddressesPagesWithContext mocks base method. -func (m *MockEC2) DescribeMovingAddressesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 func(*ec2.DescribeMovingAddressesOutput, 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, "DescribeMovingAddressesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeMovingAddressesPagesWithContext indicates an expected call of DescribeMovingAddressesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeMovingAddressesPagesWithContext(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, "DescribeMovingAddressesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeMovingAddressesPagesWithContext), varargs...) -} - -// DescribeMovingAddressesRequest mocks base method. -func (m *MockEC2) DescribeMovingAddressesRequest(arg0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeMovingAddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeMovingAddressesOutput) - return ret0, ret1 -} - -// DescribeMovingAddressesRequest indicates an expected call of DescribeMovingAddressesRequest. -func (mr *MockEC2MockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeMovingAddressesRequest), arg0) -} - -// DescribeMovingAddressesWithContext mocks base method. -func (m *MockEC2) DescribeMovingAddressesWithContext(arg0 context.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeMovingAddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeMovingAddressesWithContext indicates an expected call of DescribeMovingAddressesWithContext. -func (mr *MockEC2MockRecorder) DescribeMovingAddressesWithContext(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, "DescribeMovingAddressesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeMovingAddressesWithContext), varargs...) -} - -// DescribeNatGateways mocks base method. -func (m *MockEC2) DescribeNatGateways(arg0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNatGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNatGateways indicates an expected call of DescribeNatGateways. -func (mr *MockEC2MockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2)(nil).DescribeNatGateways), arg0) -} - -// DescribeNatGatewaysPages mocks base method. -func (m *MockEC2) DescribeNatGatewaysPages(arg0 *ec2.DescribeNatGatewaysInput, arg1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNatGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNatGatewaysPages indicates an expected call of DescribeNatGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeNatGatewaysPages), arg0, arg1) -} - -// DescribeNatGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeNatGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 func(*ec2.DescribeNatGatewaysOutput, 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, "DescribeNatGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNatGatewaysPagesWithContext indicates an expected call of DescribeNatGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNatGatewaysPagesWithContext(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, "DescribeNatGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNatGatewaysPagesWithContext), varargs...) -} - -// DescribeNatGatewaysRequest mocks base method. -func (m *MockEC2) DescribeNatGatewaysRequest(arg0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNatGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNatGatewaysOutput) - return ret0, ret1 -} - -// DescribeNatGatewaysRequest indicates an expected call of DescribeNatGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNatGatewaysRequest), arg0) -} - -// DescribeNatGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeNatGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNatGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNatGatewaysWithContext indicates an expected call of DescribeNatGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeNatGatewaysWithContext(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, "DescribeNatGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNatGatewaysWithContext), varargs...) -} - -// DescribeNetworkAcls mocks base method. -func (m *MockEC2) DescribeNetworkAcls(arg0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkAcls", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkAcls indicates an expected call of DescribeNetworkAcls. -func (mr *MockEC2MockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkAcls), arg0) -} - -// DescribeNetworkAclsPages mocks base method. -func (m *MockEC2) DescribeNetworkAclsPages(arg0 *ec2.DescribeNetworkAclsInput, arg1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkAclsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkAclsPages indicates an expected call of DescribeNetworkAclsPages. -func (mr *MockEC2MockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkAclsPages), arg0, arg1) -} - -// DescribeNetworkAclsPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkAclsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 func(*ec2.DescribeNetworkAclsOutput, 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, "DescribeNetworkAclsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkAclsPagesWithContext indicates an expected call of DescribeNetworkAclsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkAclsPagesWithContext(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, "DescribeNetworkAclsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkAclsPagesWithContext), varargs...) -} - -// DescribeNetworkAclsRequest mocks base method. -func (m *MockEC2) DescribeNetworkAclsRequest(arg0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkAclsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkAclsOutput) - return ret0, ret1 -} - -// DescribeNetworkAclsRequest indicates an expected call of DescribeNetworkAclsRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkAclsRequest), arg0) -} - -// DescribeNetworkAclsWithContext mocks base method. -func (m *MockEC2) DescribeNetworkAclsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkAclsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkAclsWithContext indicates an expected call of DescribeNetworkAclsWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkAclsWithContext(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, "DescribeNetworkAclsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkAclsWithContext), varargs...) -} - -// DescribeNetworkInsightsAccessScopeAnalyses mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopeAnalyses(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalyses", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopeAnalyses indicates an expected call of DescribeNetworkInsightsAccessScopeAnalyses. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopeAnalyses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalyses", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopeAnalyses), arg0) -} - -// DescribeNetworkInsightsAccessScopeAnalysesPages mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInsightsAccessScopeAnalysesPages indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesPages. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopeAnalysesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopeAnalysesPages), arg0, arg1) -} - -// DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, 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, "DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext(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, "DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopeAnalysesPagesWithContext), varargs...) -} - -// DescribeNetworkInsightsAccessScopeAnalysesRequest mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopeAnalysesRequest indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopeAnalysesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopeAnalysesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopeAnalysesRequest), arg0) -} - -// DescribeNetworkInsightsAccessScopeAnalysesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopeAnalysesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopeAnalysesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopeAnalysesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopeAnalysesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopeAnalysesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopeAnalysesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopeAnalysesWithContext(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, "DescribeNetworkInsightsAccessScopeAnalysesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopeAnalysesWithContext), varargs...) -} - -// DescribeNetworkInsightsAccessScopes mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopes(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopes", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopes indicates an expected call of DescribeNetworkInsightsAccessScopes. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopes", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopes), arg0) -} - -// DescribeNetworkInsightsAccessScopesPages mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopesPages(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput, arg1 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInsightsAccessScopesPages indicates an expected call of DescribeNetworkInsightsAccessScopesPages. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopesPages), arg0, arg1) -} - -// DescribeNetworkInsightsAccessScopesPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 func(*ec2.DescribeNetworkInsightsAccessScopesOutput, 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, "DescribeNetworkInsightsAccessScopesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInsightsAccessScopesPagesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopesPagesWithContext(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, "DescribeNetworkInsightsAccessScopesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopesPagesWithContext), varargs...) -} - -// DescribeNetworkInsightsAccessScopesRequest mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopesRequest(arg0 *ec2.DescribeNetworkInsightsAccessScopesInput) (*request.Request, *ec2.DescribeNetworkInsightsAccessScopesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkInsightsAccessScopesOutput) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopesRequest indicates an expected call of DescribeNetworkInsightsAccessScopesRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAccessScopesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopesRequest), arg0) -} - -// DescribeNetworkInsightsAccessScopesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAccessScopesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInsightsAccessScopesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInsightsAccessScopesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkInsightsAccessScopesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkInsightsAccessScopesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInsightsAccessScopesWithContext indicates an expected call of DescribeNetworkInsightsAccessScopesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInsightsAccessScopesWithContext(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, "DescribeNetworkInsightsAccessScopesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAccessScopesWithContext), varargs...) -} - -// DescribeNetworkInsightsAnalyses mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsAnalyses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalyses", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAnalyses), arg0) -} - -// DescribeNetworkInsightsAnalysesPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsAnalysesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAnalysesPages), arg0, arg1) -} - -// DescribeNetworkInsightsAnalysesPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAnalysesPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeNetworkInsightsAnalysesPagesWithContext), varargs...) -} - -// DescribeNetworkInsightsAnalysesRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsAnalysesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsAnalysesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsAnalysesRequest), arg0) -} - -// DescribeNetworkInsightsAnalysesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsAnalysesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeNetworkInsightsAnalysesWithContext), varargs...) -} - -// DescribeNetworkInsightsPaths mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsPaths(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPaths", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsPaths), arg0) -} - -// DescribeNetworkInsightsPathsPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsPathsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsPathsPages), arg0, arg1) -} - -// DescribeNetworkInsightsPathsPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsPathsPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeNetworkInsightsPathsPagesWithContext), varargs...) -} - -// DescribeNetworkInsightsPathsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeNetworkInsightsPathsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInsightsPathsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInsightsPathsRequest), arg0) -} - -// DescribeNetworkInsightsPathsWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInsightsPathsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeNetworkInsightsPathsWithContext), varargs...) -} - -// DescribeNetworkInterfaceAttribute mocks base method. -func (m *MockEC2) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfaceAttribute), arg0) -} - -// DescribeNetworkInterfaceAttributeRequest mocks base method. -func (m *MockEC2) DescribeNetworkInterfaceAttributeRequest(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkInterfaceAttributeOutput) - return ret0, ret1 -} - -// DescribeNetworkInterfaceAttributeRequest indicates an expected call of DescribeNetworkInterfaceAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfaceAttributeRequest), arg0) -} - -// DescribeNetworkInterfaceAttributeWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfaceAttributeWithContext indicates an expected call of DescribeNetworkInterfaceAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfaceAttributeWithContext(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, "DescribeNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfaceAttributeWithContext), varargs...) -} - -// DescribeNetworkInterfacePermissions mocks base method. -func (m *MockEC2) DescribeNetworkInterfacePermissions(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissions", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfacePermissions indicates an expected call of DescribeNetworkInterfacePermissions. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacePermissions), arg0) -} - -// DescribeNetworkInterfacePermissionsPages mocks base method. -func (m *MockEC2) DescribeNetworkInterfacePermissionsPages(arg0 *ec2.DescribeNetworkInterfacePermissionsInput, arg1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInterfacePermissionsPages indicates an expected call of DescribeNetworkInterfacePermissionsPages. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1) -} - -// DescribeNetworkInterfacePermissionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, 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, "DescribeNetworkInterfacePermissionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInterfacePermissionsPagesWithContext indicates an expected call of DescribeNetworkInterfacePermissionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacePermissionsPagesWithContext(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, "DescribeNetworkInterfacePermissionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacePermissionsPagesWithContext), varargs...) -} - -// DescribeNetworkInterfacePermissionsRequest mocks base method. -func (m *MockEC2) DescribeNetworkInterfacePermissionsRequest(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacePermissionsOutput) - return ret0, ret1 -} - -// DescribeNetworkInterfacePermissionsRequest indicates an expected call of DescribeNetworkInterfacePermissionsRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacePermissionsRequest), arg0) -} - -// DescribeNetworkInterfacePermissionsWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInterfacePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfacePermissionsWithContext indicates an expected call of DescribeNetworkInterfacePermissionsWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacePermissionsWithContext(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, "DescribeNetworkInterfacePermissionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacePermissionsWithContext), varargs...) -} - -// DescribeNetworkInterfaces mocks base method. -func (m *MockEC2) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfaces), arg0) -} - -// DescribeNetworkInterfacesAsList mocks base method. -func (m *MockEC2) DescribeNetworkInterfacesAsList(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput) ([]*ec2.NetworkInterface, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacesAsList", arg0, arg1) - ret0, _ := ret[0].([]*ec2.NetworkInterface) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfacesAsList indicates an expected call of DescribeNetworkInterfacesAsList. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesAsList", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesAsList), arg0, arg1) -} - -// DescribeNetworkInterfacesPages mocks base method. -func (m *MockEC2) DescribeNetworkInterfacesPages(arg0 *ec2.DescribeNetworkInterfacesInput, arg1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesPages), arg0, arg1) -} - -// DescribeNetworkInterfacesPagesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInterfacesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 func(*ec2.DescribeNetworkInterfacesOutput, 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, "DescribeNetworkInterfacesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeNetworkInterfacesPagesWithContext indicates an expected call of DescribeNetworkInterfacesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesPagesWithContext(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, "DescribeNetworkInterfacesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesPagesWithContext), varargs...) -} - -// DescribeNetworkInterfacesRequest mocks base method. -func (m *MockEC2) DescribeNetworkInterfacesRequest(arg0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeNetworkInterfacesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacesOutput) - return ret0, ret1 -} - -// DescribeNetworkInterfacesRequest indicates an expected call of DescribeNetworkInterfacesRequest. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesRequest), arg0) -} - -// DescribeNetworkInterfacesWithContext mocks base method. -func (m *MockEC2) DescribeNetworkInterfacesWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeNetworkInterfacesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeNetworkInterfacesWithContext indicates an expected call of DescribeNetworkInterfacesWithContext. -func (mr *MockEC2MockRecorder) DescribeNetworkInterfacesWithContext(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, "DescribeNetworkInterfacesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeNetworkInterfacesWithContext), varargs...) -} - -// DescribePlacementGroups mocks base method. -func (m *MockEC2) DescribePlacementGroups(arg0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePlacementGroups", arg0) - ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePlacementGroups indicates an expected call of DescribePlacementGroups. -func (mr *MockEC2MockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2)(nil).DescribePlacementGroups), arg0) -} - -// DescribePlacementGroupsRequest mocks base method. -func (m *MockEC2) DescribePlacementGroupsRequest(arg0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePlacementGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribePlacementGroupsOutput) - return ret0, ret1 -} - -// DescribePlacementGroupsRequest indicates an expected call of DescribePlacementGroupsRequest. -func (mr *MockEC2MockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2)(nil).DescribePlacementGroupsRequest), arg0) -} - -// DescribePlacementGroupsWithContext mocks base method. -func (m *MockEC2) DescribePlacementGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribePlacementGroupsInput, arg2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePlacementGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePlacementGroupsWithContext indicates an expected call of DescribePlacementGroupsWithContext. -func (mr *MockEC2MockRecorder) DescribePlacementGroupsWithContext(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, "DescribePlacementGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePlacementGroupsWithContext), varargs...) -} - -// DescribePrefixLists mocks base method. -func (m *MockEC2) DescribePrefixLists(arg0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrefixLists", arg0) - ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePrefixLists indicates an expected call of DescribePrefixLists. -func (mr *MockEC2MockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2)(nil).DescribePrefixLists), arg0) -} - -// DescribePrefixListsPages mocks base method. -func (m *MockEC2) DescribePrefixListsPages(arg0 *ec2.DescribePrefixListsInput, arg1 func(*ec2.DescribePrefixListsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrefixListsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePrefixListsPages indicates an expected call of DescribePrefixListsPages. -func (mr *MockEC2MockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2)(nil).DescribePrefixListsPages), arg0, arg1) -} - -// DescribePrefixListsPagesWithContext mocks base method. -func (m *MockEC2) DescribePrefixListsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 func(*ec2.DescribePrefixListsOutput, 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, "DescribePrefixListsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePrefixListsPagesWithContext indicates an expected call of DescribePrefixListsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribePrefixListsPagesWithContext(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, "DescribePrefixListsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePrefixListsPagesWithContext), varargs...) -} - -// DescribePrefixListsRequest mocks base method. -func (m *MockEC2) DescribePrefixListsRequest(arg0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrefixListsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribePrefixListsOutput) - return ret0, ret1 -} - -// DescribePrefixListsRequest indicates an expected call of DescribePrefixListsRequest. -func (mr *MockEC2MockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2)(nil).DescribePrefixListsRequest), arg0) -} - -// DescribePrefixListsWithContext mocks base method. -func (m *MockEC2) DescribePrefixListsWithContext(arg0 context.Context, arg1 *ec2.DescribePrefixListsInput, arg2 ...request.Option) (*ec2.DescribePrefixListsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePrefixListsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePrefixListsWithContext indicates an expected call of DescribePrefixListsWithContext. -func (mr *MockEC2MockRecorder) DescribePrefixListsWithContext(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, "DescribePrefixListsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePrefixListsWithContext), varargs...) -} - -// DescribePrincipalIdFormat mocks base method. -func (m *MockEC2) DescribePrincipalIdFormat(arg0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrincipalIdFormat", arg0) - ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePrincipalIdFormat indicates an expected call of DescribePrincipalIdFormat. -func (mr *MockEC2MockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2)(nil).DescribePrincipalIdFormat), arg0) -} - -// DescribePrincipalIdFormatPages mocks base method. -func (m *MockEC2) DescribePrincipalIdFormatPages(arg0 *ec2.DescribePrincipalIdFormatInput, arg1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePrincipalIdFormatPages indicates an expected call of DescribePrincipalIdFormatPages. -func (mr *MockEC2MockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2)(nil).DescribePrincipalIdFormatPages), arg0, arg1) -} - -// DescribePrincipalIdFormatPagesWithContext mocks base method. -func (m *MockEC2) DescribePrincipalIdFormatPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 func(*ec2.DescribePrincipalIdFormatOutput, 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, "DescribePrincipalIdFormatPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePrincipalIdFormatPagesWithContext indicates an expected call of DescribePrincipalIdFormatPagesWithContext. -func (mr *MockEC2MockRecorder) DescribePrincipalIdFormatPagesWithContext(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, "DescribePrincipalIdFormatPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePrincipalIdFormatPagesWithContext), varargs...) -} - -// DescribePrincipalIdFormatRequest mocks base method. -func (m *MockEC2) DescribePrincipalIdFormatRequest(arg0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePrincipalIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribePrincipalIdFormatOutput) - return ret0, ret1 -} - -// DescribePrincipalIdFormatRequest indicates an expected call of DescribePrincipalIdFormatRequest. -func (mr *MockEC2MockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).DescribePrincipalIdFormatRequest), arg0) -} - -// DescribePrincipalIdFormatWithContext mocks base method. -func (m *MockEC2) DescribePrincipalIdFormatWithContext(arg0 context.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePrincipalIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePrincipalIdFormatWithContext indicates an expected call of DescribePrincipalIdFormatWithContext. -func (mr *MockEC2MockRecorder) DescribePrincipalIdFormatWithContext(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, "DescribePrincipalIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePrincipalIdFormatWithContext), varargs...) -} - -// DescribePublicIpv4Pools mocks base method. -func (m *MockEC2) DescribePublicIpv4Pools(arg0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", arg0) - ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools. -func (mr *MockEC2MockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2)(nil).DescribePublicIpv4Pools), arg0) -} - -// DescribePublicIpv4PoolsPages mocks base method. -func (m *MockEC2) DescribePublicIpv4PoolsPages(arg0 *ec2.DescribePublicIpv4PoolsInput, arg1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePublicIpv4PoolsPages indicates an expected call of DescribePublicIpv4PoolsPages. -func (mr *MockEC2MockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2)(nil).DescribePublicIpv4PoolsPages), arg0, arg1) -} - -// DescribePublicIpv4PoolsPagesWithContext mocks base method. -func (m *MockEC2) DescribePublicIpv4PoolsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 func(*ec2.DescribePublicIpv4PoolsOutput, 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, "DescribePublicIpv4PoolsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribePublicIpv4PoolsPagesWithContext indicates an expected call of DescribePublicIpv4PoolsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribePublicIpv4PoolsPagesWithContext(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, "DescribePublicIpv4PoolsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePublicIpv4PoolsPagesWithContext), varargs...) -} - -// DescribePublicIpv4PoolsRequest mocks base method. -func (m *MockEC2) DescribePublicIpv4PoolsRequest(arg0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribePublicIpv4PoolsOutput) - return ret0, ret1 -} - -// DescribePublicIpv4PoolsRequest indicates an expected call of DescribePublicIpv4PoolsRequest. -func (mr *MockEC2MockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2)(nil).DescribePublicIpv4PoolsRequest), arg0) -} - -// DescribePublicIpv4PoolsWithContext mocks base method. -func (m *MockEC2) DescribePublicIpv4PoolsWithContext(arg0 context.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribePublicIpv4PoolsWithContext indicates an expected call of DescribePublicIpv4PoolsWithContext. -func (mr *MockEC2MockRecorder) DescribePublicIpv4PoolsWithContext(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, "DescribePublicIpv4PoolsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribePublicIpv4PoolsWithContext), varargs...) -} - -// DescribeRegions mocks base method. -func (m *MockEC2) DescribeRegions(arg0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRegions", arg0) - ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRegions indicates an expected call of DescribeRegions. -func (mr *MockEC2MockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2)(nil).DescribeRegions), arg0) -} - -// DescribeRegionsRequest mocks base method. -func (m *MockEC2) DescribeRegionsRequest(arg0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRegionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeRegionsOutput) - return ret0, ret1 -} - -// DescribeRegionsRequest indicates an expected call of DescribeRegionsRequest. -func (mr *MockEC2MockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeRegionsRequest), arg0) -} - -// DescribeRegionsWithContext mocks base method. -func (m *MockEC2) DescribeRegionsWithContext(arg0 context.Context, arg1 *ec2.DescribeRegionsInput, arg2 ...request.Option) (*ec2.DescribeRegionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeRegionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRegionsWithContext indicates an expected call of DescribeRegionsWithContext. -func (mr *MockEC2MockRecorder) DescribeRegionsWithContext(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, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeRegionsWithContext), varargs...) -} - -// DescribeReplaceRootVolumeTasks mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeReplaceRootVolumeTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasks", reflect.TypeOf((*MockEC2)(nil).DescribeReplaceRootVolumeTasks), arg0) -} - -// DescribeReplaceRootVolumeTasksPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeReplaceRootVolumeTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksPages", reflect.TypeOf((*MockEC2)(nil).DescribeReplaceRootVolumeTasksPages), arg0, arg1) -} - -// DescribeReplaceRootVolumeTasksPagesWithContext mocks base method. -func (m *MockEC2) DescribeReplaceRootVolumeTasksPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeReplaceRootVolumeTasksPagesWithContext), varargs...) -} - -// DescribeReplaceRootVolumeTasksRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeReplaceRootVolumeTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReplaceRootVolumeTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeReplaceRootVolumeTasksRequest), arg0) -} - -// DescribeReplaceRootVolumeTasksWithContext mocks base method. -func (m *MockEC2) DescribeReplaceRootVolumeTasksWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeReplaceRootVolumeTasksWithContext), varargs...) -} - -// DescribeReservedInstances mocks base method. -func (m *MockEC2) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstances indicates an expected call of DescribeReservedInstances. -func (mr *MockEC2MockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstances), arg0) -} - -// DescribeReservedInstancesListings mocks base method. -func (m *MockEC2) DescribeReservedInstancesListings(arg0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesListings", arg0) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesListings indicates an expected call of DescribeReservedInstancesListings. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesListings), arg0) -} - -// DescribeReservedInstancesListingsRequest mocks base method. -func (m *MockEC2) DescribeReservedInstancesListingsRequest(arg0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeReservedInstancesListingsOutput) - return ret0, ret1 -} - -// DescribeReservedInstancesListingsRequest indicates an expected call of DescribeReservedInstancesListingsRequest. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesListingsRequest), arg0) -} - -// DescribeReservedInstancesListingsWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesListingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesListingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesListingsWithContext indicates an expected call of DescribeReservedInstancesListingsWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesListingsWithContext(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, "DescribeReservedInstancesListingsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesListingsWithContext), varargs...) -} - -// DescribeReservedInstancesModifications mocks base method. -func (m *MockEC2) DescribeReservedInstancesModifications(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesModifications", arg0) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesModifications indicates an expected call of DescribeReservedInstancesModifications. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesModifications), arg0) -} - -// DescribeReservedInstancesModificationsPages mocks base method. -func (m *MockEC2) DescribeReservedInstancesModificationsPages(arg0 *ec2.DescribeReservedInstancesModificationsInput, arg1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeReservedInstancesModificationsPages indicates an expected call of DescribeReservedInstancesModificationsPages. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1) -} - -// DescribeReservedInstancesModificationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 func(*ec2.DescribeReservedInstancesModificationsOutput, 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, "DescribeReservedInstancesModificationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeReservedInstancesModificationsPagesWithContext indicates an expected call of DescribeReservedInstancesModificationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesModificationsPagesWithContext(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, "DescribeReservedInstancesModificationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesModificationsPagesWithContext), varargs...) -} - -// DescribeReservedInstancesModificationsRequest mocks base method. -func (m *MockEC2) DescribeReservedInstancesModificationsRequest(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeReservedInstancesModificationsOutput) - return ret0, ret1 -} - -// DescribeReservedInstancesModificationsRequest indicates an expected call of DescribeReservedInstancesModificationsRequest. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesModificationsRequest), arg0) -} - -// DescribeReservedInstancesModificationsWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesModificationsWithContext indicates an expected call of DescribeReservedInstancesModificationsWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesModificationsWithContext(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, "DescribeReservedInstancesModificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesModificationsWithContext), varargs...) -} - -// DescribeReservedInstancesOfferings mocks base method. -func (m *MockEC2) DescribeReservedInstancesOfferings(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferings", arg0) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesOfferings indicates an expected call of DescribeReservedInstancesOfferings. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesOfferings), arg0) -} - -// DescribeReservedInstancesOfferingsPages mocks base method. -func (m *MockEC2) DescribeReservedInstancesOfferingsPages(arg0 *ec2.DescribeReservedInstancesOfferingsInput, arg1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeReservedInstancesOfferingsPages indicates an expected call of DescribeReservedInstancesOfferingsPages. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1) -} - -// DescribeReservedInstancesOfferingsPagesWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesOfferingsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 func(*ec2.DescribeReservedInstancesOfferingsOutput, 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, "DescribeReservedInstancesOfferingsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeReservedInstancesOfferingsPagesWithContext indicates an expected call of DescribeReservedInstancesOfferingsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesOfferingsPagesWithContext(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, "DescribeReservedInstancesOfferingsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesOfferingsPagesWithContext), varargs...) -} - -// DescribeReservedInstancesOfferingsRequest mocks base method. -func (m *MockEC2) DescribeReservedInstancesOfferingsRequest(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOfferingsOutput) - return ret0, ret1 -} - -// DescribeReservedInstancesOfferingsRequest indicates an expected call of DescribeReservedInstancesOfferingsRequest. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesOfferingsRequest), arg0) -} - -// DescribeReservedInstancesOfferingsWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesOfferingsWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesOfferingsWithContext indicates an expected call of DescribeReservedInstancesOfferingsWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesOfferingsWithContext(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, "DescribeReservedInstancesOfferingsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesOfferingsWithContext), varargs...) -} - -// DescribeReservedInstancesRequest mocks base method. -func (m *MockEC2) DescribeReservedInstancesRequest(arg0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeReservedInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOutput) - return ret0, ret1 -} - -// DescribeReservedInstancesRequest indicates an expected call of DescribeReservedInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesRequest), arg0) -} - -// DescribeReservedInstancesWithContext mocks base method. -func (m *MockEC2) DescribeReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeReservedInstancesInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeReservedInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeReservedInstancesWithContext indicates an expected call of DescribeReservedInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeReservedInstancesWithContext(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, "DescribeReservedInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeReservedInstancesWithContext), varargs...) -} - -// DescribeRouteTables mocks base method. -func (m *MockEC2) DescribeRouteTables(arg0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRouteTables", arg0) - ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRouteTables indicates an expected call of DescribeRouteTables. -func (mr *MockEC2MockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2)(nil).DescribeRouteTables), arg0) -} - -// DescribeRouteTablesPages mocks base method. -func (m *MockEC2) DescribeRouteTablesPages(arg0 *ec2.DescribeRouteTablesInput, arg1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRouteTablesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeRouteTablesPages indicates an expected call of DescribeRouteTablesPages. -func (mr *MockEC2MockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2)(nil).DescribeRouteTablesPages), arg0, arg1) -} - -// DescribeRouteTablesPagesWithContext mocks base method. -func (m *MockEC2) DescribeRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 func(*ec2.DescribeRouteTablesOutput, 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, "DescribeRouteTablesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeRouteTablesPagesWithContext indicates an expected call of DescribeRouteTablesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeRouteTablesPagesWithContext(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, "DescribeRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeRouteTablesPagesWithContext), varargs...) -} - -// DescribeRouteTablesRequest mocks base method. -func (m *MockEC2) DescribeRouteTablesRequest(arg0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRouteTablesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeRouteTablesOutput) - return ret0, ret1 -} - -// DescribeRouteTablesRequest indicates an expected call of DescribeRouteTablesRequest. -func (mr *MockEC2MockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeRouteTablesRequest), arg0) -} - -// DescribeRouteTablesWithContext mocks base method. -func (m *MockEC2) DescribeRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeRouteTablesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeRouteTablesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRouteTablesWithContext indicates an expected call of DescribeRouteTablesWithContext. -func (mr *MockEC2MockRecorder) DescribeRouteTablesWithContext(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, "DescribeRouteTablesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeRouteTablesWithContext), varargs...) -} - -// DescribeScheduledInstanceAvailability mocks base method. -func (m *MockEC2) DescribeScheduledInstanceAvailability(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailability", arg0) - ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeScheduledInstanceAvailability indicates an expected call of DescribeScheduledInstanceAvailability. -func (mr *MockEC2MockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstanceAvailability), arg0) -} - -// DescribeScheduledInstanceAvailabilityPages mocks base method. -func (m *MockEC2) DescribeScheduledInstanceAvailabilityPages(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput, arg1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeScheduledInstanceAvailabilityPages indicates an expected call of DescribeScheduledInstanceAvailabilityPages. -func (mr *MockEC2MockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1) -} - -// DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method. -func (m *MockEC2) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, 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, "DescribeScheduledInstanceAvailabilityPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeScheduledInstanceAvailabilityPagesWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeScheduledInstanceAvailabilityPagesWithContext(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, "DescribeScheduledInstanceAvailabilityPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstanceAvailabilityPagesWithContext), varargs...) -} - -// DescribeScheduledInstanceAvailabilityRequest mocks base method. -func (m *MockEC2) DescribeScheduledInstanceAvailabilityRequest(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeScheduledInstanceAvailabilityOutput) - return ret0, ret1 -} - -// DescribeScheduledInstanceAvailabilityRequest indicates an expected call of DescribeScheduledInstanceAvailabilityRequest. -func (mr *MockEC2MockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0) -} - -// DescribeScheduledInstanceAvailabilityWithContext mocks base method. -func (m *MockEC2) DescribeScheduledInstanceAvailabilityWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeScheduledInstanceAvailabilityWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityWithContext. -func (mr *MockEC2MockRecorder) DescribeScheduledInstanceAvailabilityWithContext(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, "DescribeScheduledInstanceAvailabilityWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstanceAvailabilityWithContext), varargs...) -} - -// DescribeScheduledInstances mocks base method. -func (m *MockEC2) DescribeScheduledInstances(arg0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeScheduledInstances indicates an expected call of DescribeScheduledInstances. -func (mr *MockEC2MockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstances), arg0) -} - -// DescribeScheduledInstancesPages mocks base method. -func (m *MockEC2) DescribeScheduledInstancesPages(arg0 *ec2.DescribeScheduledInstancesInput, arg1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstancesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeScheduledInstancesPages indicates an expected call of DescribeScheduledInstancesPages. -func (mr *MockEC2MockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstancesPages), arg0, arg1) -} - -// DescribeScheduledInstancesPagesWithContext mocks base method. -func (m *MockEC2) DescribeScheduledInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 func(*ec2.DescribeScheduledInstancesOutput, 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, "DescribeScheduledInstancesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeScheduledInstancesPagesWithContext indicates an expected call of DescribeScheduledInstancesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeScheduledInstancesPagesWithContext(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, "DescribeScheduledInstancesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstancesPagesWithContext), varargs...) -} - -// DescribeScheduledInstancesRequest mocks base method. -func (m *MockEC2) DescribeScheduledInstancesRequest(arg0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeScheduledInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeScheduledInstancesOutput) - return ret0, ret1 -} - -// DescribeScheduledInstancesRequest indicates an expected call of DescribeScheduledInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstancesRequest), arg0) -} - -// DescribeScheduledInstancesWithContext mocks base method. -func (m *MockEC2) DescribeScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeScheduledInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeScheduledInstancesWithContext indicates an expected call of DescribeScheduledInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeScheduledInstancesWithContext(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, "DescribeScheduledInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeScheduledInstancesWithContext), varargs...) -} - -// DescribeSecurityGroupReferences mocks base method. -func (m *MockEC2) DescribeSecurityGroupReferences(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupReferences), arg0) -} - -// DescribeSecurityGroupReferencesRequest mocks base method. -func (m *MockEC2) DescribeSecurityGroupReferencesRequest(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSecurityGroupReferencesOutput) - return ret0, ret1 -} - -// DescribeSecurityGroupReferencesRequest indicates an expected call of DescribeSecurityGroupReferencesRequest. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupReferencesRequest), arg0) -} - -// DescribeSecurityGroupReferencesWithContext mocks base method. -func (m *MockEC2) DescribeSecurityGroupReferencesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupReferencesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupReferencesWithContext indicates an expected call of DescribeSecurityGroupReferencesWithContext. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupReferencesWithContext(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, "DescribeSecurityGroupReferencesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupReferencesWithContext), varargs...) -} - -// DescribeSecurityGroupRules mocks base method. -func (m *MockEC2) DescribeSecurityGroupRules(arg0 *ec2.DescribeSecurityGroupRulesInput) (*ec2.DescribeSecurityGroupRulesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupRules", arg0) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupRules indicates an expected call of DescribeSecurityGroupRules. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupRules(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRules", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupRules), arg0) -} - -// DescribeSecurityGroupRulesPages mocks base method. -func (m *MockEC2) DescribeSecurityGroupRulesPages(arg0 *ec2.DescribeSecurityGroupRulesInput, arg1 func(*ec2.DescribeSecurityGroupRulesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSecurityGroupRulesPages indicates an expected call of DescribeSecurityGroupRulesPages. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupRulesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesPages", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupRulesPages), arg0, arg1) -} - -// DescribeSecurityGroupRulesPagesWithContext mocks base method. -func (m *MockEC2) DescribeSecurityGroupRulesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 func(*ec2.DescribeSecurityGroupRulesOutput, 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, "DescribeSecurityGroupRulesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSecurityGroupRulesPagesWithContext indicates an expected call of DescribeSecurityGroupRulesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupRulesPagesWithContext(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, "DescribeSecurityGroupRulesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupRulesPagesWithContext), varargs...) -} - -// DescribeSecurityGroupRulesRequest mocks base method. -func (m *MockEC2) DescribeSecurityGroupRulesRequest(arg0 *ec2.DescribeSecurityGroupRulesInput) (*request.Request, *ec2.DescribeSecurityGroupRulesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSecurityGroupRulesOutput) - return ret0, ret1 -} - -// DescribeSecurityGroupRulesRequest indicates an expected call of DescribeSecurityGroupRulesRequest. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupRulesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupRulesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupRulesRequest), arg0) -} - -// DescribeSecurityGroupRulesWithContext mocks base method. -func (m *MockEC2) DescribeSecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupRulesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupRulesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSecurityGroupRulesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupRulesWithContext indicates an expected call of DescribeSecurityGroupRulesWithContext. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupRulesWithContext(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, "DescribeSecurityGroupRulesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupRulesWithContext), varargs...) -} - -// DescribeSecurityGroups mocks base method. -func (m *MockEC2) DescribeSecurityGroups(arg0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups. -func (mr *MockEC2MockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroups), arg0) -} - -// DescribeSecurityGroupsAsList mocks base method. -func (m *MockEC2) DescribeSecurityGroupsAsList(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput) ([]*ec2.SecurityGroup, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupsAsList", arg0, arg1) - ret0, _ := ret[0].([]*ec2.SecurityGroup) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupsAsList indicates an expected call of DescribeSecurityGroupsAsList. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupsAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsAsList), arg0, arg1) -} - -// DescribeSecurityGroupsPages mocks base method. -func (m *MockEC2) DescribeSecurityGroupsPages(arg0 *ec2.DescribeSecurityGroupsInput, arg1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSecurityGroupsPages indicates an expected call of DescribeSecurityGroupsPages. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsPages), arg0, arg1) -} - -// DescribeSecurityGroupsPagesWithContext mocks base method. -func (m *MockEC2) DescribeSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 func(*ec2.DescribeSecurityGroupsOutput, 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, "DescribeSecurityGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSecurityGroupsPagesWithContext indicates an expected call of DescribeSecurityGroupsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupsPagesWithContext(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, "DescribeSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsPagesWithContext), varargs...) -} - -// DescribeSecurityGroupsRequest mocks base method. -func (m *MockEC2) DescribeSecurityGroupsRequest(arg0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSecurityGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSecurityGroupsOutput) - return ret0, ret1 -} - -// DescribeSecurityGroupsRequest indicates an expected call of DescribeSecurityGroupsRequest. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsRequest), arg0) -} - -// DescribeSecurityGroupsWithContext mocks base method. -func (m *MockEC2) DescribeSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSecurityGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSecurityGroupsWithContext indicates an expected call of DescribeSecurityGroupsWithContext. -func (mr *MockEC2MockRecorder) DescribeSecurityGroupsWithContext(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, "DescribeSecurityGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSecurityGroupsWithContext), varargs...) -} - -// DescribeSnapshotAttribute mocks base method. -func (m *MockEC2) DescribeSnapshotAttribute(arg0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshotAttribute indicates an expected call of DescribeSnapshotAttribute. -func (mr *MockEC2MockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotAttribute), arg0) -} - -// DescribeSnapshotAttributeRequest mocks base method. -func (m *MockEC2) DescribeSnapshotAttributeRequest(arg0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSnapshotAttributeOutput) - return ret0, ret1 -} - -// DescribeSnapshotAttributeRequest indicates an expected call of DescribeSnapshotAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotAttributeRequest), arg0) -} - -// DescribeSnapshotAttributeWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotAttributeInput, arg2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSnapshotAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshotAttributeWithContext indicates an expected call of DescribeSnapshotAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotAttributeWithContext(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, "DescribeSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotAttributeWithContext), varargs...) -} - -// DescribeSnapshotTierStatus mocks base method. -func (m *MockEC2) DescribeSnapshotTierStatus(arg0 *ec2.DescribeSnapshotTierStatusInput) (*ec2.DescribeSnapshotTierStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotTierStatus", arg0) - ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshotTierStatus indicates an expected call of DescribeSnapshotTierStatus. -func (mr *MockEC2MockRecorder) DescribeSnapshotTierStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatus", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotTierStatus), arg0) -} - -// DescribeSnapshotTierStatusPages mocks base method. -func (m *MockEC2) DescribeSnapshotTierStatusPages(arg0 *ec2.DescribeSnapshotTierStatusInput, arg1 func(*ec2.DescribeSnapshotTierStatusOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSnapshotTierStatusPages indicates an expected call of DescribeSnapshotTierStatusPages. -func (mr *MockEC2MockRecorder) DescribeSnapshotTierStatusPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusPages", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotTierStatusPages), arg0, arg1) -} - -// DescribeSnapshotTierStatusPagesWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotTierStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 func(*ec2.DescribeSnapshotTierStatusOutput, 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, "DescribeSnapshotTierStatusPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSnapshotTierStatusPagesWithContext indicates an expected call of DescribeSnapshotTierStatusPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotTierStatusPagesWithContext(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, "DescribeSnapshotTierStatusPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotTierStatusPagesWithContext), varargs...) -} - -// DescribeSnapshotTierStatusRequest mocks base method. -func (m *MockEC2) DescribeSnapshotTierStatusRequest(arg0 *ec2.DescribeSnapshotTierStatusInput) (*request.Request, *ec2.DescribeSnapshotTierStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSnapshotTierStatusOutput) - return ret0, ret1 -} - -// DescribeSnapshotTierStatusRequest indicates an expected call of DescribeSnapshotTierStatusRequest. -func (mr *MockEC2MockRecorder) DescribeSnapshotTierStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotTierStatusRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotTierStatusRequest), arg0) -} - -// DescribeSnapshotTierStatusWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotTierStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotTierStatusInput, arg2 ...request.Option) (*ec2.DescribeSnapshotTierStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSnapshotTierStatusWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSnapshotTierStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshotTierStatusWithContext indicates an expected call of DescribeSnapshotTierStatusWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotTierStatusWithContext(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, "DescribeSnapshotTierStatusWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotTierStatusWithContext), varargs...) -} - -// DescribeSnapshots mocks base method. -func (m *MockEC2) DescribeSnapshots(arg0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshots", arg0) - ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshots indicates an expected call of DescribeSnapshots. -func (mr *MockEC2MockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshots), arg0) -} - -// DescribeSnapshotsPages mocks base method. -func (m *MockEC2) DescribeSnapshotsPages(arg0 *ec2.DescribeSnapshotsInput, arg1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages. -func (mr *MockEC2MockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotsPages), arg0, arg1) -} - -// DescribeSnapshotsPagesWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 func(*ec2.DescribeSnapshotsOutput, 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, "DescribeSnapshotsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotsPagesWithContext(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, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotsPagesWithContext), varargs...) -} - -// DescribeSnapshotsRequest mocks base method. -func (m *MockEC2) DescribeSnapshotsRequest(arg0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSnapshotsOutput) - return ret0, ret1 -} - -// DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest. -func (mr *MockEC2MockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotsRequest), arg0) -} - -// DescribeSnapshotsWithContext mocks base method. -func (m *MockEC2) DescribeSnapshotsWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext. -func (mr *MockEC2MockRecorder) DescribeSnapshotsWithContext(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, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSnapshotsWithContext), varargs...) -} - -// DescribeSpotDatafeedSubscription mocks base method. -func (m *MockEC2) DescribeSpotDatafeedSubscription(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscription", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotDatafeedSubscription indicates an expected call of DescribeSpotDatafeedSubscription. -func (mr *MockEC2MockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2)(nil).DescribeSpotDatafeedSubscription), arg0) -} - -// DescribeSpotDatafeedSubscriptionRequest mocks base method. -func (m *MockEC2) DescribeSpotDatafeedSubscriptionRequest(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotDatafeedSubscriptionOutput) - return ret0, ret1 -} - -// DescribeSpotDatafeedSubscriptionRequest indicates an expected call of DescribeSpotDatafeedSubscriptionRequest. -func (mr *MockEC2MockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0) -} - -// DescribeSpotDatafeedSubscriptionWithContext mocks base method. -func (m *MockEC2) DescribeSpotDatafeedSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotDatafeedSubscriptionWithContext indicates an expected call of DescribeSpotDatafeedSubscriptionWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotDatafeedSubscriptionWithContext(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, "DescribeSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotDatafeedSubscriptionWithContext), varargs...) -} - -// DescribeSpotFleetInstances mocks base method. -func (m *MockEC2) DescribeSpotFleetInstances(arg0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetInstances indicates an expected call of DescribeSpotFleetInstances. -func (mr *MockEC2MockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetInstances), arg0) -} - -// DescribeSpotFleetInstancesRequest mocks base method. -func (m *MockEC2) DescribeSpotFleetInstancesRequest(arg0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotFleetInstancesOutput) - return ret0, ret1 -} - -// DescribeSpotFleetInstancesRequest indicates an expected call of DescribeSpotFleetInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetInstancesRequest), arg0) -} - -// DescribeSpotFleetInstancesWithContext mocks base method. -func (m *MockEC2) DescribeSpotFleetInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetInstancesWithContext indicates an expected call of DescribeSpotFleetInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotFleetInstancesWithContext(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, "DescribeSpotFleetInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetInstancesWithContext), varargs...) -} - -// DescribeSpotFleetRequestHistory mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestHistory(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistory", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetRequestHistory indicates an expected call of DescribeSpotFleetRequestHistory. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestHistory), arg0) -} - -// DescribeSpotFleetRequestHistoryRequest mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestHistoryRequest(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestHistoryOutput) - return ret0, ret1 -} - -// DescribeSpotFleetRequestHistoryRequest indicates an expected call of DescribeSpotFleetRequestHistoryRequest. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestHistoryRequest), arg0) -} - -// DescribeSpotFleetRequestHistoryWithContext mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetRequestHistoryWithContext indicates an expected call of DescribeSpotFleetRequestHistoryWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestHistoryWithContext(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, "DescribeSpotFleetRequestHistoryWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestHistoryWithContext), varargs...) -} - -// DescribeSpotFleetRequests mocks base method. -func (m *MockEC2) DescribeSpotFleetRequests(arg0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetRequests", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetRequests indicates an expected call of DescribeSpotFleetRequests. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequests), arg0) -} - -// DescribeSpotFleetRequestsPages mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestsPages(arg0 *ec2.DescribeSpotFleetRequestsInput, arg1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotFleetRequestsPages indicates an expected call of DescribeSpotFleetRequestsPages. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestsPages), arg0, arg1) -} - -// DescribeSpotFleetRequestsPagesWithContext mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 func(*ec2.DescribeSpotFleetRequestsOutput, 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, "DescribeSpotFleetRequestsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotFleetRequestsPagesWithContext indicates an expected call of DescribeSpotFleetRequestsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestsPagesWithContext(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, "DescribeSpotFleetRequestsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestsPagesWithContext), varargs...) -} - -// DescribeSpotFleetRequestsRequest mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestsRequest(arg0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestsOutput) - return ret0, ret1 -} - -// DescribeSpotFleetRequestsRequest indicates an expected call of DescribeSpotFleetRequestsRequest. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestsRequest), arg0) -} - -// DescribeSpotFleetRequestsWithContext mocks base method. -func (m *MockEC2) DescribeSpotFleetRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotFleetRequestsWithContext indicates an expected call of DescribeSpotFleetRequestsWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotFleetRequestsWithContext(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, "DescribeSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotFleetRequestsWithContext), varargs...) -} - -// DescribeSpotInstanceRequests mocks base method. -func (m *MockEC2) DescribeSpotInstanceRequests(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotInstanceRequests", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotInstanceRequests indicates an expected call of DescribeSpotInstanceRequests. -func (mr *MockEC2MockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2)(nil).DescribeSpotInstanceRequests), arg0) -} - -// DescribeSpotInstanceRequestsPages mocks base method. -func (m *MockEC2) DescribeSpotInstanceRequestsPages(arg0 *ec2.DescribeSpotInstanceRequestsInput, arg1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotInstanceRequestsPages indicates an expected call of DescribeSpotInstanceRequestsPages. -func (mr *MockEC2MockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1) -} - -// DescribeSpotInstanceRequestsPagesWithContext mocks base method. -func (m *MockEC2) DescribeSpotInstanceRequestsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 func(*ec2.DescribeSpotInstanceRequestsOutput, 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, "DescribeSpotInstanceRequestsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotInstanceRequestsPagesWithContext indicates an expected call of DescribeSpotInstanceRequestsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotInstanceRequestsPagesWithContext(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, "DescribeSpotInstanceRequestsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotInstanceRequestsPagesWithContext), varargs...) -} - -// DescribeSpotInstanceRequestsRequest mocks base method. -func (m *MockEC2) DescribeSpotInstanceRequestsRequest(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotInstanceRequestsOutput) - return ret0, ret1 -} - -// DescribeSpotInstanceRequestsRequest indicates an expected call of DescribeSpotInstanceRequestsRequest. -func (mr *MockEC2MockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotInstanceRequestsRequest), arg0) -} - -// DescribeSpotInstanceRequestsWithContext mocks base method. -func (m *MockEC2) DescribeSpotInstanceRequestsWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotInstanceRequestsWithContext indicates an expected call of DescribeSpotInstanceRequestsWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotInstanceRequestsWithContext(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, "DescribeSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotInstanceRequestsWithContext), varargs...) -} - -// DescribeSpotPriceHistory mocks base method. -func (m *MockEC2) DescribeSpotPriceHistory(arg0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotPriceHistory", arg0) - ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotPriceHistory indicates an expected call of DescribeSpotPriceHistory. -func (mr *MockEC2MockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2)(nil).DescribeSpotPriceHistory), arg0) -} - -// DescribeSpotPriceHistoryPages mocks base method. -func (m *MockEC2) DescribeSpotPriceHistoryPages(arg0 *ec2.DescribeSpotPriceHistoryInput, arg1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotPriceHistoryPages indicates an expected call of DescribeSpotPriceHistoryPages. -func (mr *MockEC2MockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2)(nil).DescribeSpotPriceHistoryPages), arg0, arg1) -} - -// DescribeSpotPriceHistoryPagesWithContext mocks base method. -func (m *MockEC2) DescribeSpotPriceHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 func(*ec2.DescribeSpotPriceHistoryOutput, 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, "DescribeSpotPriceHistoryPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeSpotPriceHistoryPagesWithContext indicates an expected call of DescribeSpotPriceHistoryPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotPriceHistoryPagesWithContext(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, "DescribeSpotPriceHistoryPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotPriceHistoryPagesWithContext), varargs...) -} - -// DescribeSpotPriceHistoryRequest mocks base method. -func (m *MockEC2) DescribeSpotPriceHistoryRequest(arg0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeSpotPriceHistoryOutput) - return ret0, ret1 -} - -// DescribeSpotPriceHistoryRequest indicates an expected call of DescribeSpotPriceHistoryRequest. -func (mr *MockEC2MockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSpotPriceHistoryRequest), arg0) -} - -// DescribeSpotPriceHistoryWithContext mocks base method. -func (m *MockEC2) DescribeSpotPriceHistoryWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSpotPriceHistoryWithContext indicates an expected call of DescribeSpotPriceHistoryWithContext. -func (mr *MockEC2MockRecorder) DescribeSpotPriceHistoryWithContext(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, "DescribeSpotPriceHistoryWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeSpotPriceHistoryWithContext), varargs...) -} - -// DescribeStaleSecurityGroups mocks base method. -func (m *MockEC2) DescribeStaleSecurityGroups(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStaleSecurityGroups", arg0) - ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeStaleSecurityGroups indicates an expected call of DescribeStaleSecurityGroups. -func (mr *MockEC2MockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2)(nil).DescribeStaleSecurityGroups), arg0) -} - -// DescribeStaleSecurityGroupsPages mocks base method. -func (m *MockEC2) DescribeStaleSecurityGroupsPages(arg0 *ec2.DescribeStaleSecurityGroupsInput, arg1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeStaleSecurityGroupsPages indicates an expected call of DescribeStaleSecurityGroupsPages. -func (mr *MockEC2MockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1) -} - -// DescribeStaleSecurityGroupsPagesWithContext mocks base method. -func (m *MockEC2) DescribeStaleSecurityGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 func(*ec2.DescribeStaleSecurityGroupsOutput, 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, "DescribeStaleSecurityGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeStaleSecurityGroupsPagesWithContext indicates an expected call of DescribeStaleSecurityGroupsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeStaleSecurityGroupsPagesWithContext(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, "DescribeStaleSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeStaleSecurityGroupsPagesWithContext), varargs...) -} - -// DescribeStaleSecurityGroupsRequest mocks base method. -func (m *MockEC2) DescribeStaleSecurityGroupsRequest(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeStaleSecurityGroupsOutput) - return ret0, ret1 -} - -// DescribeStaleSecurityGroupsRequest indicates an expected call of DescribeStaleSecurityGroupsRequest. -func (mr *MockEC2MockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeStaleSecurityGroupsRequest), arg0) -} - -// DescribeStaleSecurityGroupsWithContext mocks base method. -func (m *MockEC2) DescribeStaleSecurityGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeStaleSecurityGroupsWithContext indicates an expected call of DescribeStaleSecurityGroupsWithContext. -func (mr *MockEC2MockRecorder) DescribeStaleSecurityGroupsWithContext(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, "DescribeStaleSecurityGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeStaleSecurityGroupsWithContext), varargs...) -} - -// DescribeStoreImageTasks mocks base method. -func (m *MockEC2) DescribeStoreImageTasks(arg0 *ec2.DescribeStoreImageTasksInput) (*ec2.DescribeStoreImageTasksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStoreImageTasks", arg0) - ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeStoreImageTasks indicates an expected call of DescribeStoreImageTasks. -func (mr *MockEC2MockRecorder) DescribeStoreImageTasks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasks", reflect.TypeOf((*MockEC2)(nil).DescribeStoreImageTasks), arg0) -} - -// DescribeStoreImageTasksPages mocks base method. -func (m *MockEC2) DescribeStoreImageTasksPages(arg0 *ec2.DescribeStoreImageTasksInput, arg1 func(*ec2.DescribeStoreImageTasksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStoreImageTasksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeStoreImageTasksPages indicates an expected call of DescribeStoreImageTasksPages. -func (mr *MockEC2MockRecorder) DescribeStoreImageTasksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksPages", reflect.TypeOf((*MockEC2)(nil).DescribeStoreImageTasksPages), arg0, arg1) -} - -// DescribeStoreImageTasksPagesWithContext mocks base method. -func (m *MockEC2) DescribeStoreImageTasksPagesWithContext(arg0 context.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, "DescribeStoreImageTasksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeStoreImageTasksPagesWithContext indicates an expected call of DescribeStoreImageTasksPagesWithContext. -func (mr *MockEC2MockRecorder) 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, "DescribeStoreImageTasksPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeStoreImageTasksPagesWithContext), varargs...) -} - -// DescribeStoreImageTasksRequest mocks base method. -func (m *MockEC2) DescribeStoreImageTasksRequest(arg0 *ec2.DescribeStoreImageTasksInput) (*request.Request, *ec2.DescribeStoreImageTasksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeStoreImageTasksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeStoreImageTasksOutput) - return ret0, ret1 -} - -// DescribeStoreImageTasksRequest indicates an expected call of DescribeStoreImageTasksRequest. -func (mr *MockEC2MockRecorder) DescribeStoreImageTasksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStoreImageTasksRequest", reflect.TypeOf((*MockEC2)(nil).DescribeStoreImageTasksRequest), arg0) -} - -// DescribeStoreImageTasksWithContext mocks base method. -func (m *MockEC2) DescribeStoreImageTasksWithContext(arg0 context.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, "DescribeStoreImageTasksWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeStoreImageTasksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeStoreImageTasksWithContext indicates an expected call of DescribeStoreImageTasksWithContext. -func (mr *MockEC2MockRecorder) 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, "DescribeStoreImageTasksWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeStoreImageTasksWithContext), varargs...) -} - -// DescribeSubnets mocks base method. -func (m *MockEC2) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnets", arg0) - ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSubnets indicates an expected call of DescribeSubnets. -func (mr *MockEC2MockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2)(nil).DescribeSubnets), arg0) -} - -// DescribeSubnetsAsList mocks base method. -func (m *MockEC2) DescribeSubnetsAsList(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubnetsAsList", arg0, arg1) - ret0, _ := ret[0].([]*ec2.Subnet) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSubnetsAsList indicates an expected call of DescribeSubnetsAsList. -func (mr *MockEC2MockRecorder) DescribeSubnetsAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeSubnetsAsList), arg0, arg1) -} - -// DescribeSubnetsPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2)(nil).DescribeSubnetsPages), arg0, arg1) -} - -// DescribeSubnetsPagesWithContext mocks base method. -func (m *MockEC2) DescribeSubnetsPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeSubnetsPagesWithContext), varargs...) -} - -// DescribeSubnetsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeSubnetsRequest), arg0) -} - -// DescribeSubnetsWithContext mocks base method. -func (m *MockEC2) DescribeSubnetsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeSubnetsWithContext), varargs...) -} - -// DescribeTags mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2)(nil).DescribeTags), arg0) -} - -// DescribeTagsPages mocks base method. -func (m *MockEC2) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTagsPages indicates an expected call of DescribeTagsPages. -func (mr *MockEC2MockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTagsPages), arg0, arg1) -} - -// DescribeTagsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTagsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, 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, "DescribeTagsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTagsPagesWithContext(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, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTagsPagesWithContext), varargs...) -} - -// DescribeTagsRequest mocks base method. -func (m *MockEC2) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTagsOutput) - return ret0, ret1 -} - -// DescribeTagsRequest indicates an expected call of DescribeTagsRequest. -func (mr *MockEC2MockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTagsRequest), arg0) -} - -// DescribeTagsWithContext mocks base method. -func (m *MockEC2) DescribeTagsWithContext(arg0 context.Context, arg1 *ec2.DescribeTagsInput, arg2 ...request.Option) (*ec2.DescribeTagsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext. -func (mr *MockEC2MockRecorder) DescribeTagsWithContext(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, "DescribeTagsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTagsWithContext), varargs...) -} - -// DescribeTrafficMirrorFilters mocks base method. -func (m *MockEC2) DescribeTrafficMirrorFilters(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilters", arg0) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorFilters indicates an expected call of DescribeTrafficMirrorFilters. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorFilters), arg0) -} - -// DescribeTrafficMirrorFiltersPages mocks base method. -func (m *MockEC2) DescribeTrafficMirrorFiltersPages(arg0 *ec2.DescribeTrafficMirrorFiltersInput, arg1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorFiltersPages indicates an expected call of DescribeTrafficMirrorFiltersPages. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1) -} - -// DescribeTrafficMirrorFiltersPagesWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorFiltersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 func(*ec2.DescribeTrafficMirrorFiltersOutput, 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, "DescribeTrafficMirrorFiltersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorFiltersPagesWithContext indicates an expected call of DescribeTrafficMirrorFiltersPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorFiltersPagesWithContext(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, "DescribeTrafficMirrorFiltersPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorFiltersPagesWithContext), varargs...) -} - -// DescribeTrafficMirrorFiltersRequest mocks base method. -func (m *MockEC2) DescribeTrafficMirrorFiltersRequest(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFiltersOutput) - return ret0, ret1 -} - -// DescribeTrafficMirrorFiltersRequest indicates an expected call of DescribeTrafficMirrorFiltersRequest. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorFiltersRequest), arg0) -} - -// DescribeTrafficMirrorFiltersWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorFiltersWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorFiltersWithContext indicates an expected call of DescribeTrafficMirrorFiltersWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorFiltersWithContext(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, "DescribeTrafficMirrorFiltersWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorFiltersWithContext), varargs...) -} - -// DescribeTrafficMirrorSessions mocks base method. -func (m *MockEC2) DescribeTrafficMirrorSessions(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessions", arg0) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorSessions indicates an expected call of DescribeTrafficMirrorSessions. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorSessions), arg0) -} - -// DescribeTrafficMirrorSessionsPages mocks base method. -func (m *MockEC2) DescribeTrafficMirrorSessionsPages(arg0 *ec2.DescribeTrafficMirrorSessionsInput, arg1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorSessionsPages indicates an expected call of DescribeTrafficMirrorSessionsPages. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1) -} - -// DescribeTrafficMirrorSessionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorSessionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 func(*ec2.DescribeTrafficMirrorSessionsOutput, 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, "DescribeTrafficMirrorSessionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorSessionsPagesWithContext indicates an expected call of DescribeTrafficMirrorSessionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorSessionsPagesWithContext(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, "DescribeTrafficMirrorSessionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorSessionsPagesWithContext), varargs...) -} - -// DescribeTrafficMirrorSessionsRequest mocks base method. -func (m *MockEC2) DescribeTrafficMirrorSessionsRequest(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorSessionsOutput) - return ret0, ret1 -} - -// DescribeTrafficMirrorSessionsRequest indicates an expected call of DescribeTrafficMirrorSessionsRequest. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorSessionsRequest), arg0) -} - -// DescribeTrafficMirrorSessionsWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorSessionsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorSessionsWithContext indicates an expected call of DescribeTrafficMirrorSessionsWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorSessionsWithContext(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, "DescribeTrafficMirrorSessionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorSessionsWithContext), varargs...) -} - -// DescribeTrafficMirrorTargets mocks base method. -func (m *MockEC2) DescribeTrafficMirrorTargets(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargets", arg0) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorTargets indicates an expected call of DescribeTrafficMirrorTargets. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorTargets), arg0) -} - -// DescribeTrafficMirrorTargetsPages mocks base method. -func (m *MockEC2) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1) -} - -// DescribeTrafficMirrorTargetsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorTargetsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, 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, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrafficMirrorTargetsPagesWithContext indicates an expected call of DescribeTrafficMirrorTargetsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorTargetsPagesWithContext(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, "DescribeTrafficMirrorTargetsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...) -} - -// DescribeTrafficMirrorTargetsRequest mocks base method. -func (m *MockEC2) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput) - return ret0, ret1 -} - -// DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorTargetsRequest), arg0) -} - -// DescribeTrafficMirrorTargetsWithContext mocks base method. -func (m *MockEC2) DescribeTrafficMirrorTargetsWithContext(arg0 context.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrafficMirrorTargetsWithContext indicates an expected call of DescribeTrafficMirrorTargetsWithContext. -func (mr *MockEC2MockRecorder) DescribeTrafficMirrorTargetsWithContext(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, "DescribeTrafficMirrorTargetsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...) -} - -// DescribeTransitGatewayAttachments mocks base method. -func (m *MockEC2) DescribeTransitGatewayAttachments(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachments", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayAttachments indicates an expected call of DescribeTransitGatewayAttachments. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayAttachments), arg0) -} - -// DescribeTransitGatewayAttachmentsPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayAttachmentsPages(arg0 *ec2.DescribeTransitGatewayAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayAttachmentsPages indicates an expected call of DescribeTransitGatewayAttachmentsPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1) -} - -// DescribeTransitGatewayAttachmentsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, 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, "DescribeTransitGatewayAttachmentsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayAttachmentsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayAttachmentsPagesWithContext(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, "DescribeTransitGatewayAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayAttachmentsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayAttachmentsRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayAttachmentsOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayAttachmentsRequest indicates an expected call of DescribeTransitGatewayAttachmentsRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayAttachmentsRequest), arg0) -} - -// DescribeTransitGatewayAttachmentsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayAttachmentsWithContext indicates an expected call of DescribeTransitGatewayAttachmentsWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayAttachmentsWithContext(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, "DescribeTransitGatewayAttachmentsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...) -} - -// DescribeTransitGatewayConnectPeers mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnectPeers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeers", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnectPeers), arg0) -} - -// DescribeTransitGatewayConnectPeersPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnectPeersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnectPeersPages), arg0, arg1) -} - -// DescribeTransitGatewayConnectPeersPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayConnectPeersPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeTransitGatewayConnectPeersPagesWithContext), varargs...) -} - -// DescribeTransitGatewayConnectPeersRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnectPeersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectPeersRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnectPeersRequest), arg0) -} - -// DescribeTransitGatewayConnectPeersWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayConnectPeersWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeTransitGatewayConnectPeersWithContext), varargs...) -} - -// DescribeTransitGatewayConnects mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnects(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnects", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnects), arg0) -} - -// DescribeTransitGatewayConnectsPages mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnectsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnectsPages), arg0, arg1) -} - -// DescribeTransitGatewayConnectsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayConnectsPagesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeTransitGatewayConnectsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayConnectsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTransitGatewayConnectsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayConnectsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayConnectsRequest), arg0) -} - -// DescribeTransitGatewayConnectsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayConnectsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeTransitGatewayConnectsWithContext), varargs...) -} - -// DescribeTransitGatewayMulticastDomains mocks base method. -func (m *MockEC2) DescribeTransitGatewayMulticastDomains(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomains", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayMulticastDomains indicates an expected call of DescribeTransitGatewayMulticastDomains. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayMulticastDomains(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomains", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayMulticastDomains), arg0) -} - -// DescribeTransitGatewayMulticastDomainsPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayMulticastDomainsPages(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg1 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayMulticastDomainsPages indicates an expected call of DescribeTransitGatewayMulticastDomainsPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayMulticastDomainsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayMulticastDomainsPages), arg0, arg1) -} - -// DescribeTransitGatewayMulticastDomainsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 func(*ec2.DescribeTransitGatewayMulticastDomainsOutput, 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, "DescribeTransitGatewayMulticastDomainsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayMulticastDomainsPagesWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayMulticastDomainsPagesWithContext(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, "DescribeTransitGatewayMulticastDomainsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayMulticastDomainsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayMulticastDomainsRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayMulticastDomainsRequest(arg0 *ec2.DescribeTransitGatewayMulticastDomainsInput) (*request.Request, *ec2.DescribeTransitGatewayMulticastDomainsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayMulticastDomainsRequest indicates an expected call of DescribeTransitGatewayMulticastDomainsRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayMulticastDomainsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayMulticastDomainsRequest), arg0) -} - -// DescribeTransitGatewayMulticastDomainsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayMulticastDomainsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayMulticastDomainsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayMulticastDomainsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayMulticastDomainsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayMulticastDomainsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayMulticastDomainsWithContext indicates an expected call of DescribeTransitGatewayMulticastDomainsWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayMulticastDomainsWithContext(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, "DescribeTransitGatewayMulticastDomainsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayMulticastDomainsWithContext), varargs...) -} - -// DescribeTransitGatewayPeeringAttachments mocks base method. -func (m *MockEC2) DescribeTransitGatewayPeeringAttachments(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachments", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayPeeringAttachments indicates an expected call of DescribeTransitGatewayPeeringAttachments. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPeeringAttachments(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachments", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPeeringAttachments), arg0) -} - -// DescribeTransitGatewayPeeringAttachmentsPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayPeeringAttachmentsPages(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayPeeringAttachmentsPages indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPeeringAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPeeringAttachmentsPages), arg0, arg1) -} - -// DescribeTransitGatewayPeeringAttachmentsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, 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, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayPeeringAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(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, "DescribeTransitGatewayPeeringAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPeeringAttachmentsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayPeeringAttachmentsRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayPeeringAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayPeeringAttachmentsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayPeeringAttachmentsRequest indicates an expected call of DescribeTransitGatewayPeeringAttachmentsRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPeeringAttachmentsRequest), arg0) -} - -// DescribeTransitGatewayPeeringAttachmentsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPeeringAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPeeringAttachmentsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayPeeringAttachmentsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPeeringAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayPeeringAttachmentsWithContext indicates an expected call of DescribeTransitGatewayPeeringAttachmentsWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPeeringAttachmentsWithContext(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, "DescribeTransitGatewayPeeringAttachmentsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPeeringAttachmentsWithContext), varargs...) -} - -// DescribeTransitGatewayPolicyTables mocks base method. -func (m *MockEC2) DescribeTransitGatewayPolicyTables(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTables", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayPolicyTables indicates an expected call of DescribeTransitGatewayPolicyTables. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPolicyTables(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTables", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPolicyTables), arg0) -} - -// DescribeTransitGatewayPolicyTablesPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayPolicyTablesPages(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput, arg1 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayPolicyTablesPages indicates an expected call of DescribeTransitGatewayPolicyTablesPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPolicyTablesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPolicyTablesPages), arg0, arg1) -} - -// DescribeTransitGatewayPolicyTablesPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayPolicyTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 func(*ec2.DescribeTransitGatewayPolicyTablesOutput, 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, "DescribeTransitGatewayPolicyTablesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayPolicyTablesPagesWithContext indicates an expected call of DescribeTransitGatewayPolicyTablesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPolicyTablesPagesWithContext(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, "DescribeTransitGatewayPolicyTablesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPolicyTablesPagesWithContext), varargs...) -} - -// DescribeTransitGatewayPolicyTablesRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayPolicyTablesRequest(arg0 *ec2.DescribeTransitGatewayPolicyTablesInput) (*request.Request, *ec2.DescribeTransitGatewayPolicyTablesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayPolicyTablesOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayPolicyTablesRequest indicates an expected call of DescribeTransitGatewayPolicyTablesRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPolicyTablesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPolicyTablesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPolicyTablesRequest), arg0) -} - -// DescribeTransitGatewayPolicyTablesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayPolicyTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayPolicyTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayPolicyTablesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayPolicyTablesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayPolicyTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayPolicyTablesWithContext indicates an expected call of DescribeTransitGatewayPolicyTablesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayPolicyTablesWithContext(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, "DescribeTransitGatewayPolicyTablesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayPolicyTablesWithContext), varargs...) -} - -// DescribeTransitGatewayRouteTableAnnouncements mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTableAnnouncements(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncements", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTableAnnouncements indicates an expected call of DescribeTransitGatewayRouteTableAnnouncements. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTableAnnouncements(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncements", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTableAnnouncements), arg0) -} - -// DescribeTransitGatewayRouteTableAnnouncementsPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg1 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayRouteTableAnnouncementsPages indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTableAnnouncementsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTableAnnouncementsPages), arg0, arg1) -} - -// DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 func(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, 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, "DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext(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, "DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTableAnnouncementsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayRouteTableAnnouncementsRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTableAnnouncementsRequest indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTableAnnouncementsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTableAnnouncementsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTableAnnouncementsRequest), arg0) -} - -// DescribeTransitGatewayRouteTableAnnouncementsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTableAnnouncementsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTableAnnouncementsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTableAnnouncementsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTableAnnouncementsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTableAnnouncementsWithContext indicates an expected call of DescribeTransitGatewayRouteTableAnnouncementsWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTableAnnouncementsWithContext(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, "DescribeTransitGatewayRouteTableAnnouncementsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTableAnnouncementsWithContext), varargs...) -} - -// DescribeTransitGatewayRouteTables mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTables(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTables", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTables indicates an expected call of DescribeTransitGatewayRouteTables. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTables), arg0) -} - -// DescribeTransitGatewayRouteTablesPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTablesPages(arg0 *ec2.DescribeTransitGatewayRouteTablesInput, arg1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayRouteTablesPages indicates an expected call of DescribeTransitGatewayRouteTablesPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1) -} - -// DescribeTransitGatewayRouteTablesPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, 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, "DescribeTransitGatewayRouteTablesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayRouteTablesPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTablesPagesWithContext(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, "DescribeTransitGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTablesPagesWithContext), varargs...) -} - -// DescribeTransitGatewayRouteTablesRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTablesRequest(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTablesOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTablesRequest indicates an expected call of DescribeTransitGatewayRouteTablesRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTablesRequest), arg0) -} - -// DescribeTransitGatewayRouteTablesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayRouteTablesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayRouteTablesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayRouteTablesWithContext(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, "DescribeTransitGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayRouteTablesWithContext), varargs...) -} - -// DescribeTransitGatewayVpcAttachments mocks base method. -func (m *MockEC2) DescribeTransitGatewayVpcAttachments(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachments", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayVpcAttachments indicates an expected call of DescribeTransitGatewayVpcAttachments. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayVpcAttachments), arg0) -} - -// DescribeTransitGatewayVpcAttachmentsPages mocks base method. -func (m *MockEC2) DescribeTransitGatewayVpcAttachmentsPages(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayVpcAttachmentsPages indicates an expected call of DescribeTransitGatewayVpcAttachmentsPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1) -} - -// DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, 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, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewayVpcAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayVpcAttachmentsPagesWithContext(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, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayVpcAttachmentsPagesWithContext), varargs...) -} - -// DescribeTransitGatewayVpcAttachmentsRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewayVpcAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) - return ret0, ret1 -} - -// DescribeTransitGatewayVpcAttachmentsRequest indicates an expected call of DescribeTransitGatewayVpcAttachmentsRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0) -} - -// DescribeTransitGatewayVpcAttachmentsWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewayVpcAttachmentsWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewayVpcAttachmentsWithContext(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, "DescribeTransitGatewayVpcAttachmentsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewayVpcAttachmentsWithContext), varargs...) -} - -// DescribeTransitGateways mocks base method. -func (m *MockEC2) DescribeTransitGateways(arg0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGateways indicates an expected call of DescribeTransitGateways. -func (mr *MockEC2MockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGateways), arg0) -} - -// DescribeTransitGatewaysPages mocks base method. -func (m *MockEC2) DescribeTransitGatewaysPages(arg0 *ec2.DescribeTransitGatewaysInput, arg1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewaysPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewaysPages indicates an expected call of DescribeTransitGatewaysPages. -func (mr *MockEC2MockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewaysPages), arg0, arg1) -} - -// DescribeTransitGatewaysPagesWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewaysPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 func(*ec2.DescribeTransitGatewaysOutput, 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, "DescribeTransitGatewaysPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTransitGatewaysPagesWithContext indicates an expected call of DescribeTransitGatewaysPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewaysPagesWithContext(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, "DescribeTransitGatewaysPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewaysPagesWithContext), varargs...) -} - -// DescribeTransitGatewaysRequest mocks base method. -func (m *MockEC2) DescribeTransitGatewaysRequest(arg0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTransitGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeTransitGatewaysOutput) - return ret0, ret1 -} - -// DescribeTransitGatewaysRequest indicates an expected call of DescribeTransitGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewaysRequest), arg0) -} - -// DescribeTransitGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeTransitGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTransitGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTransitGatewaysWithContext indicates an expected call of DescribeTransitGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeTransitGatewaysWithContext(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, "DescribeTransitGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTransitGatewaysWithContext), varargs...) -} - -// DescribeTrunkInterfaceAssociations mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTrunkInterfaceAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociations", reflect.TypeOf((*MockEC2)(nil).DescribeTrunkInterfaceAssociations), arg0) -} - -// DescribeTrunkInterfaceAssociationsPages mocks base method. -func (m *MockEC2) DescribeTrunkInterfaceAssociationsPages(arg0 *ec2.DescribeTrunkInterfaceAssociationsInput, arg1 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrunkInterfaceAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrunkInterfaceAssociationsPages indicates an expected call of DescribeTrunkInterfaceAssociationsPages. -func (mr *MockEC2MockRecorder) DescribeTrunkInterfaceAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeTrunkInterfaceAssociationsPages), arg0, arg1) -} - -// DescribeTrunkInterfaceAssociationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeTrunkInterfaceAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeTrunkInterfaceAssociationsInput, arg2 func(*ec2.DescribeTrunkInterfaceAssociationsOutput, 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, "DescribeTrunkInterfaceAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrunkInterfaceAssociationsPagesWithContext indicates an expected call of DescribeTrunkInterfaceAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeTrunkInterfaceAssociationsPagesWithContext(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, "DescribeTrunkInterfaceAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeTrunkInterfaceAssociationsPagesWithContext), varargs...) -} - -// DescribeTrunkInterfaceAssociationsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DescribeTrunkInterfaceAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrunkInterfaceAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeTrunkInterfaceAssociationsRequest), arg0) -} - -// DescribeTrunkInterfaceAssociationsWithContext mocks base method. -func (m *MockEC2) DescribeTrunkInterfaceAssociationsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DescribeTrunkInterfaceAssociationsWithContext), varargs...) -} - -// DescribeVPCsAsList mocks base method. -func (m *MockEC2) DescribeVPCsAsList(arg0 context.Context, arg1 *ec2.DescribeVpcsInput) ([]*ec2.Vpc, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVPCsAsList", arg0, arg1) - ret0, _ := ret[0].([]*ec2.Vpc) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVPCsAsList indicates an expected call of DescribeVPCsAsList. -func (mr *MockEC2MockRecorder) DescribeVPCsAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVPCsAsList", reflect.TypeOf((*MockEC2)(nil).DescribeVPCsAsList), arg0, arg1) -} - -// DescribeVerifiedAccessEndpoints mocks base method. -func (m *MockEC2) DescribeVerifiedAccessEndpoints(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpoints", arg0) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessEndpoints indicates an expected call of DescribeVerifiedAccessEndpoints. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessEndpoints(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpoints", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessEndpoints), arg0) -} - -// DescribeVerifiedAccessEndpointsPages mocks base method. -func (m *MockEC2) DescribeVerifiedAccessEndpointsPages(arg0 *ec2.DescribeVerifiedAccessEndpointsInput, arg1 func(*ec2.DescribeVerifiedAccessEndpointsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessEndpointsPages indicates an expected call of DescribeVerifiedAccessEndpointsPages. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessEndpointsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessEndpointsPages), arg0, arg1) -} - -// DescribeVerifiedAccessEndpointsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 func(*ec2.DescribeVerifiedAccessEndpointsOutput, 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, "DescribeVerifiedAccessEndpointsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessEndpointsPagesWithContext indicates an expected call of DescribeVerifiedAccessEndpointsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessEndpointsPagesWithContext(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, "DescribeVerifiedAccessEndpointsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessEndpointsPagesWithContext), varargs...) -} - -// DescribeVerifiedAccessEndpointsRequest mocks base method. -func (m *MockEC2) DescribeVerifiedAccessEndpointsRequest(arg0 *ec2.DescribeVerifiedAccessEndpointsInput) (*request.Request, *ec2.DescribeVerifiedAccessEndpointsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessEndpointsOutput) - return ret0, ret1 -} - -// DescribeVerifiedAccessEndpointsRequest indicates an expected call of DescribeVerifiedAccessEndpointsRequest. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessEndpointsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessEndpointsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessEndpointsRequest), arg0) -} - -// DescribeVerifiedAccessEndpointsWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessEndpointsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVerifiedAccessEndpointsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessEndpointsWithContext indicates an expected call of DescribeVerifiedAccessEndpointsWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessEndpointsWithContext(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, "DescribeVerifiedAccessEndpointsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessEndpointsWithContext), varargs...) -} - -// DescribeVerifiedAccessGroups mocks base method. -func (m *MockEC2) DescribeVerifiedAccessGroups(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*ec2.DescribeVerifiedAccessGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroups", arg0) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessGroups indicates an expected call of DescribeVerifiedAccessGroups. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroups", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessGroups), arg0) -} - -// DescribeVerifiedAccessGroupsPages mocks base method. -func (m *MockEC2) DescribeVerifiedAccessGroupsPages(arg0 *ec2.DescribeVerifiedAccessGroupsInput, arg1 func(*ec2.DescribeVerifiedAccessGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessGroupsPages indicates an expected call of DescribeVerifiedAccessGroupsPages. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessGroupsPages), arg0, arg1) -} - -// DescribeVerifiedAccessGroupsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 func(*ec2.DescribeVerifiedAccessGroupsOutput, 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, "DescribeVerifiedAccessGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessGroupsPagesWithContext indicates an expected call of DescribeVerifiedAccessGroupsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessGroupsPagesWithContext(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, "DescribeVerifiedAccessGroupsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessGroupsPagesWithContext), varargs...) -} - -// DescribeVerifiedAccessGroupsRequest mocks base method. -func (m *MockEC2) DescribeVerifiedAccessGroupsRequest(arg0 *ec2.DescribeVerifiedAccessGroupsInput) (*request.Request, *ec2.DescribeVerifiedAccessGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessGroupsOutput) - return ret0, ret1 -} - -// DescribeVerifiedAccessGroupsRequest indicates an expected call of DescribeVerifiedAccessGroupsRequest. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessGroupsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessGroupsRequest), arg0) -} - -// DescribeVerifiedAccessGroupsWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessGroupsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessGroupsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVerifiedAccessGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessGroupsWithContext indicates an expected call of DescribeVerifiedAccessGroupsWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessGroupsWithContext(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, "DescribeVerifiedAccessGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessGroupsWithContext), varargs...) -} - -// DescribeVerifiedAccessInstanceLoggingConfigurations mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurations", arg0) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstanceLoggingConfigurations indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurations. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurations", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstanceLoggingConfigurations), arg0) -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsPages mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg1 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsPages indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsPages. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsPages), arg0, arg1) -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 func(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, 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, "DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext(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, "DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsPagesWithContext), varargs...) -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput) (*request.Request, *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsRequest indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsRequest. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstanceLoggingConfigurationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsRequest), arg0) -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstanceLoggingConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext indicates an expected call of DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext(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, "DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstanceLoggingConfigurationsWithContext), varargs...) -} - -// DescribeVerifiedAccessInstances mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstances(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*ec2.DescribeVerifiedAccessInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstances", arg0) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstances indicates an expected call of DescribeVerifiedAccessInstances. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstances", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstances), arg0) -} - -// DescribeVerifiedAccessInstancesPages mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstancesPages(arg0 *ec2.DescribeVerifiedAccessInstancesInput, arg1 func(*ec2.DescribeVerifiedAccessInstancesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessInstancesPages indicates an expected call of DescribeVerifiedAccessInstancesPages. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstancesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesPages", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstancesPages), arg0, arg1) -} - -// DescribeVerifiedAccessInstancesPagesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstancesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 func(*ec2.DescribeVerifiedAccessInstancesOutput, 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, "DescribeVerifiedAccessInstancesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessInstancesPagesWithContext indicates an expected call of DescribeVerifiedAccessInstancesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstancesPagesWithContext(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, "DescribeVerifiedAccessInstancesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstancesPagesWithContext), varargs...) -} - -// DescribeVerifiedAccessInstancesRequest mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstancesRequest(arg0 *ec2.DescribeVerifiedAccessInstancesInput) (*request.Request, *ec2.DescribeVerifiedAccessInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessInstancesOutput) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstancesRequest indicates an expected call of DescribeVerifiedAccessInstancesRequest. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessInstancesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstancesRequest), arg0) -} - -// DescribeVerifiedAccessInstancesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessInstancesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessInstancesInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVerifiedAccessInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessInstancesWithContext indicates an expected call of DescribeVerifiedAccessInstancesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessInstancesWithContext(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, "DescribeVerifiedAccessInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessInstancesWithContext), varargs...) -} - -// DescribeVerifiedAccessTrustProviders mocks base method. -func (m *MockEC2) DescribeVerifiedAccessTrustProviders(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProviders", arg0) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessTrustProviders indicates an expected call of DescribeVerifiedAccessTrustProviders. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessTrustProviders(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProviders", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessTrustProviders), arg0) -} - -// DescribeVerifiedAccessTrustProvidersPages mocks base method. -func (m *MockEC2) DescribeVerifiedAccessTrustProvidersPages(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg1 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessTrustProvidersPages indicates an expected call of DescribeVerifiedAccessTrustProvidersPages. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessTrustProvidersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersPages", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessTrustProvidersPages), arg0, arg1) -} - -// DescribeVerifiedAccessTrustProvidersPagesWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessTrustProvidersPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 func(*ec2.DescribeVerifiedAccessTrustProvidersOutput, 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, "DescribeVerifiedAccessTrustProvidersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVerifiedAccessTrustProvidersPagesWithContext indicates an expected call of DescribeVerifiedAccessTrustProvidersPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessTrustProvidersPagesWithContext(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, "DescribeVerifiedAccessTrustProvidersPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessTrustProvidersPagesWithContext), varargs...) -} - -// DescribeVerifiedAccessTrustProvidersRequest mocks base method. -func (m *MockEC2) DescribeVerifiedAccessTrustProvidersRequest(arg0 *ec2.DescribeVerifiedAccessTrustProvidersInput) (*request.Request, *ec2.DescribeVerifiedAccessTrustProvidersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVerifiedAccessTrustProvidersOutput) - return ret0, ret1 -} - -// DescribeVerifiedAccessTrustProvidersRequest indicates an expected call of DescribeVerifiedAccessTrustProvidersRequest. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessTrustProvidersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVerifiedAccessTrustProvidersRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessTrustProvidersRequest), arg0) -} - -// DescribeVerifiedAccessTrustProvidersWithContext mocks base method. -func (m *MockEC2) DescribeVerifiedAccessTrustProvidersWithContext(arg0 context.Context, arg1 *ec2.DescribeVerifiedAccessTrustProvidersInput, arg2 ...request.Option) (*ec2.DescribeVerifiedAccessTrustProvidersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVerifiedAccessTrustProvidersWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVerifiedAccessTrustProvidersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVerifiedAccessTrustProvidersWithContext indicates an expected call of DescribeVerifiedAccessTrustProvidersWithContext. -func (mr *MockEC2MockRecorder) DescribeVerifiedAccessTrustProvidersWithContext(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, "DescribeVerifiedAccessTrustProvidersWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVerifiedAccessTrustProvidersWithContext), varargs...) -} - -// DescribeVolumeAttribute mocks base method. -func (m *MockEC2) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumeAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumeAttribute indicates an expected call of DescribeVolumeAttribute. -func (mr *MockEC2MockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeAttribute), arg0) -} - -// DescribeVolumeAttributeRequest mocks base method. -func (m *MockEC2) DescribeVolumeAttributeRequest(arg0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumeAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVolumeAttributeOutput) - return ret0, ret1 -} - -// DescribeVolumeAttributeRequest indicates an expected call of DescribeVolumeAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeAttributeRequest), arg0) -} - -// DescribeVolumeAttributeWithContext mocks base method. -func (m *MockEC2) DescribeVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeAttributeInput, arg2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVolumeAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumeAttributeWithContext indicates an expected call of DescribeVolumeAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumeAttributeWithContext(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, "DescribeVolumeAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeAttributeWithContext), varargs...) -} - -// DescribeVolumeStatus mocks base method. -func (m *MockEC2) DescribeVolumeStatus(arg0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumeStatus", arg0) - ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumeStatus indicates an expected call of DescribeVolumeStatus. -func (mr *MockEC2MockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeStatus), arg0) -} - -// DescribeVolumeStatusPages mocks base method. -func (m *MockEC2) DescribeVolumeStatusPages(arg0 *ec2.DescribeVolumeStatusInput, arg1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumeStatusPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumeStatusPages indicates an expected call of DescribeVolumeStatusPages. -func (mr *MockEC2MockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeStatusPages), arg0, arg1) -} - -// DescribeVolumeStatusPagesWithContext mocks base method. -func (m *MockEC2) DescribeVolumeStatusPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 func(*ec2.DescribeVolumeStatusOutput, 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, "DescribeVolumeStatusPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumeStatusPagesWithContext indicates an expected call of DescribeVolumeStatusPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumeStatusPagesWithContext(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, "DescribeVolumeStatusPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeStatusPagesWithContext), varargs...) -} - -// DescribeVolumeStatusRequest mocks base method. -func (m *MockEC2) DescribeVolumeStatusRequest(arg0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumeStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVolumeStatusOutput) - return ret0, ret1 -} - -// DescribeVolumeStatusRequest indicates an expected call of DescribeVolumeStatusRequest. -func (mr *MockEC2MockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeStatusRequest), arg0) -} - -// DescribeVolumeStatusWithContext mocks base method. -func (m *MockEC2) DescribeVolumeStatusWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVolumeStatusWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumeStatusWithContext indicates an expected call of DescribeVolumeStatusWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumeStatusWithContext(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, "DescribeVolumeStatusWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumeStatusWithContext), varargs...) -} - -// DescribeVolumes mocks base method. -func (m *MockEC2) DescribeVolumes(arg0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumes", arg0) - ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumes indicates an expected call of DescribeVolumes. -func (mr *MockEC2MockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2)(nil).DescribeVolumes), arg0) -} - -// DescribeVolumesModifications mocks base method. -func (m *MockEC2) DescribeVolumesModifications(arg0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumesModifications", arg0) - ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumesModifications indicates an expected call of DescribeVolumesModifications. -func (mr *MockEC2MockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModifications), arg0) -} - -// DescribeVolumesModificationsPages mocks base method. -func (m *MockEC2) DescribeVolumesModificationsPages(arg0 *ec2.DescribeVolumesModificationsInput, arg1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumesModificationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumesModificationsPages indicates an expected call of DescribeVolumesModificationsPages. -func (mr *MockEC2MockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModificationsPages), arg0, arg1) -} - -// DescribeVolumesModificationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVolumesModificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 func(*ec2.DescribeVolumesModificationsOutput, 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, "DescribeVolumesModificationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumesModificationsPagesWithContext indicates an expected call of DescribeVolumesModificationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesModificationsPagesWithContext(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, "DescribeVolumesModificationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModificationsPagesWithContext), varargs...) -} - -// DescribeVolumesModificationsRequest mocks base method. -func (m *MockEC2) DescribeVolumesModificationsRequest(arg0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumesModificationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVolumesModificationsOutput) - return ret0, ret1 -} - -// DescribeVolumesModificationsRequest indicates an expected call of DescribeVolumesModificationsRequest. -func (mr *MockEC2MockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModificationsRequest), arg0) -} - -// DescribeVolumesModificationsWithContext mocks base method. -func (m *MockEC2) DescribeVolumesModificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumesModificationsWithContext indicates an expected call of DescribeVolumesModificationsWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesModificationsWithContext(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, "DescribeVolumesModificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesModificationsWithContext), varargs...) -} - -// DescribeVolumesPages mocks base method. -func (m *MockEC2) DescribeVolumesPages(arg0 *ec2.DescribeVolumesInput, arg1 func(*ec2.DescribeVolumesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumesPages indicates an expected call of DescribeVolumesPages. -func (mr *MockEC2MockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesPages), arg0, arg1) -} - -// DescribeVolumesPagesWithContext mocks base method. -func (m *MockEC2) DescribeVolumesPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 func(*ec2.DescribeVolumesOutput, 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, "DescribeVolumesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVolumesPagesWithContext indicates an expected call of DescribeVolumesPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesPagesWithContext(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, "DescribeVolumesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesPagesWithContext), varargs...) -} - -// DescribeVolumesRequest mocks base method. -func (m *MockEC2) DescribeVolumesRequest(arg0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVolumesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVolumesOutput) - return ret0, ret1 -} - -// DescribeVolumesRequest indicates an expected call of DescribeVolumesRequest. -func (mr *MockEC2MockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesRequest), arg0) -} - -// DescribeVolumesWithContext mocks base method. -func (m *MockEC2) DescribeVolumesWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVolumesWithContext indicates an expected call of DescribeVolumesWithContext. -func (mr *MockEC2MockRecorder) DescribeVolumesWithContext(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, "DescribeVolumesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVolumesWithContext), varargs...) -} - -// DescribeVpcAttribute mocks base method. -func (m *MockEC2) DescribeVpcAttribute(arg0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcAttribute", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute. -func (mr *MockEC2MockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2)(nil).DescribeVpcAttribute), arg0) -} - -// DescribeVpcAttributeRequest mocks base method. -func (m *MockEC2) DescribeVpcAttributeRequest(arg0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcAttributeOutput) - return ret0, ret1 -} - -// DescribeVpcAttributeRequest indicates an expected call of DescribeVpcAttributeRequest. -func (mr *MockEC2MockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcAttributeRequest), arg0) -} - -// DescribeVpcAttributeWithContext mocks base method. -func (m *MockEC2) DescribeVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcAttributeWithContext indicates an expected call of DescribeVpcAttributeWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcAttributeWithContext(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, "DescribeVpcAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcAttributeWithContext), varargs...) -} - -// DescribeVpcClassicLink mocks base method. -func (m *MockEC2) DescribeVpcClassicLink(arg0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcClassicLink", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcClassicLink indicates an expected call of DescribeVpcClassicLink. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLink), arg0) -} - -// DescribeVpcClassicLinkDnsSupport mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkDnsSupport(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupport", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcClassicLinkDnsSupport indicates an expected call of DescribeVpcClassicLinkDnsSupport. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkDnsSupport), arg0) -} - -// DescribeVpcClassicLinkDnsSupportPages mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkDnsSupportPages(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcClassicLinkDnsSupportPages indicates an expected call of DescribeVpcClassicLinkDnsSupportPages. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1) -} - -// DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, 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, "DescribeVpcClassicLinkDnsSupportPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcClassicLinkDnsSupportPagesWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkDnsSupportPagesWithContext(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, "DescribeVpcClassicLinkDnsSupportPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkDnsSupportPagesWithContext), varargs...) -} - -// DescribeVpcClassicLinkDnsSupportRequest mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkDnsSupportRequest(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) - return ret0, ret1 -} - -// DescribeVpcClassicLinkDnsSupportRequest indicates an expected call of DescribeVpcClassicLinkDnsSupportRequest. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0) -} - -// DescribeVpcClassicLinkDnsSupportWithContext mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcClassicLinkDnsSupportWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkDnsSupportWithContext(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, "DescribeVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkDnsSupportWithContext), varargs...) -} - -// DescribeVpcClassicLinkRequest mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkRequest(arg0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkOutput) - return ret0, ret1 -} - -// DescribeVpcClassicLinkRequest indicates an expected call of DescribeVpcClassicLinkRequest. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkRequest), arg0) -} - -// DescribeVpcClassicLinkWithContext mocks base method. -func (m *MockEC2) DescribeVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcClassicLinkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcClassicLinkWithContext indicates an expected call of DescribeVpcClassicLinkWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcClassicLinkWithContext(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, "DescribeVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcClassicLinkWithContext), varargs...) -} - -// DescribeVpcEndpointConnectionNotifications mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionNotifications(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotifications", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointConnectionNotifications indicates an expected call of DescribeVpcEndpointConnectionNotifications. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionNotifications), arg0) -} - -// DescribeVpcEndpointConnectionNotificationsPages mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionNotificationsPages(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointConnectionNotificationsPages indicates an expected call of DescribeVpcEndpointConnectionNotificationsPages. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1) -} - -// DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, 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, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointConnectionNotificationsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionNotificationsPagesWithContext(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, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionNotificationsPagesWithContext), varargs...) -} - -// DescribeVpcEndpointConnectionNotificationsRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointConnectionNotificationsRequest indicates an expected call of DescribeVpcEndpointConnectionNotificationsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0) -} - -// DescribeVpcEndpointConnectionNotificationsWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointConnectionNotificationsWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionNotificationsWithContext(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, "DescribeVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionNotificationsWithContext), varargs...) -} - -// DescribeVpcEndpointConnections mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnections(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnections", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointConnections indicates an expected call of DescribeVpcEndpointConnections. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnections), arg0) -} - -// DescribeVpcEndpointConnectionsPages mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionsPages(arg0 *ec2.DescribeVpcEndpointConnectionsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointConnectionsPages indicates an expected call of DescribeVpcEndpointConnectionsPages. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1) -} - -// DescribeVpcEndpointConnectionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionsOutput, 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, "DescribeVpcEndpointConnectionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointConnectionsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionsPagesWithContext(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, "DescribeVpcEndpointConnectionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionsPagesWithContext), varargs...) -} - -// DescribeVpcEndpointConnectionsRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionsRequest(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionsOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointConnectionsRequest indicates an expected call of DescribeVpcEndpointConnectionsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionsRequest), arg0) -} - -// DescribeVpcEndpointConnectionsWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointConnectionsWithContext indicates an expected call of DescribeVpcEndpointConnectionsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointConnectionsWithContext(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, "DescribeVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointConnectionsWithContext), varargs...) -} - -// DescribeVpcEndpointServiceConfigurations mocks base method. -func (m *MockEC2) DescribeVpcEndpointServiceConfigurations(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurations", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServiceConfigurations indicates an expected call of DescribeVpcEndpointServiceConfigurations. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServiceConfigurations), arg0) -} - -// DescribeVpcEndpointServiceConfigurationsPages mocks base method. -func (m *MockEC2) DescribeVpcEndpointServiceConfigurationsPages(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointServiceConfigurationsPages indicates an expected call of DescribeVpcEndpointServiceConfigurationsPages. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1) -} - -// DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, 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, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointServiceConfigurationsPagesWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServiceConfigurationsPagesWithContext(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, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServiceConfigurationsPagesWithContext), varargs...) -} - -// DescribeVpcEndpointServiceConfigurationsRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointServiceConfigurationsRequest indicates an expected call of DescribeVpcEndpointServiceConfigurationsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0) -} - -// DescribeVpcEndpointServiceConfigurationsWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServiceConfigurationsWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServiceConfigurationsWithContext(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, "DescribeVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServiceConfigurationsWithContext), varargs...) -} - -// DescribeVpcEndpointServicePermissions mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicePermissions(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissions", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServicePermissions indicates an expected call of DescribeVpcEndpointServicePermissions. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicePermissions), arg0) -} - -// DescribeVpcEndpointServicePermissionsPages mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicePermissionsPages(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput, arg1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointServicePermissionsPages indicates an expected call of DescribeVpcEndpointServicePermissionsPages. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1) -} - -// DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, 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, "DescribeVpcEndpointServicePermissionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointServicePermissionsPagesWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicePermissionsPagesWithContext(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, "DescribeVpcEndpointServicePermissionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicePermissionsPagesWithContext), varargs...) -} - -// DescribeVpcEndpointServicePermissionsRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicePermissionsRequest(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicePermissionsOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointServicePermissionsRequest indicates an expected call of DescribeVpcEndpointServicePermissionsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0) -} - -// DescribeVpcEndpointServicePermissionsWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServicePermissionsWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicePermissionsWithContext(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, "DescribeVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicePermissionsWithContext), varargs...) -} - -// DescribeVpcEndpointServices mocks base method. -func (m *MockEC2) DescribeVpcEndpointServices(arg0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServices", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServices indicates an expected call of DescribeVpcEndpointServices. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServices), arg0) -} - -// DescribeVpcEndpointServicesRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicesRequest(arg0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicesOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointServicesRequest indicates an expected call of DescribeVpcEndpointServicesRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicesRequest), arg0) -} - -// DescribeVpcEndpointServicesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointServicesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointServicesInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointServicesWithContext indicates an expected call of DescribeVpcEndpointServicesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointServicesWithContext(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, "DescribeVpcEndpointServicesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointServicesWithContext), varargs...) -} - -// DescribeVpcEndpoints mocks base method. -func (m *MockEC2) DescribeVpcEndpoints(arg0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpoints", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints. -func (mr *MockEC2MockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpoints), arg0) -} - -// DescribeVpcEndpointsPages mocks base method. -func (m *MockEC2) DescribeVpcEndpointsPages(arg0 *ec2.DescribeVpcEndpointsInput, arg1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointsPages indicates an expected call of DescribeVpcEndpointsPages. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointsPages), arg0, arg1) -} - -// DescribeVpcEndpointsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, 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, "DescribeVpcEndpointsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcEndpointsPagesWithContext indicates an expected call of DescribeVpcEndpointsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointsPagesWithContext(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, "DescribeVpcEndpointsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointsPagesWithContext), varargs...) -} - -// DescribeVpcEndpointsRequest mocks base method. -func (m *MockEC2) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput) - return ret0, ret1 -} - -// DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointsRequest), arg0) -} - -// DescribeVpcEndpointsWithContext mocks base method. -func (m *MockEC2) DescribeVpcEndpointsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcEndpointsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcEndpointsWithContext indicates an expected call of DescribeVpcEndpointsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcEndpointsWithContext(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, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcEndpointsWithContext), varargs...) -} - -// DescribeVpcPeeringConnections mocks base method. -func (m *MockEC2) DescribeVpcPeeringConnections(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections. -func (mr *MockEC2MockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2)(nil).DescribeVpcPeeringConnections), arg0) -} - -// DescribeVpcPeeringConnectionsPages mocks base method. -func (m *MockEC2) DescribeVpcPeeringConnectionsPages(arg0 *ec2.DescribeVpcPeeringConnectionsInput, arg1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcPeeringConnectionsPages indicates an expected call of DescribeVpcPeeringConnectionsPages. -func (mr *MockEC2MockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1) -} - -// DescribeVpcPeeringConnectionsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcPeeringConnectionsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 func(*ec2.DescribeVpcPeeringConnectionsOutput, 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, "DescribeVpcPeeringConnectionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcPeeringConnectionsPagesWithContext indicates an expected call of DescribeVpcPeeringConnectionsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcPeeringConnectionsPagesWithContext(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, "DescribeVpcPeeringConnectionsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcPeeringConnectionsPagesWithContext), varargs...) -} - -// DescribeVpcPeeringConnectionsRequest mocks base method. -func (m *MockEC2) DescribeVpcPeeringConnectionsRequest(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcPeeringConnectionsOutput) - return ret0, ret1 -} - -// DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcPeeringConnectionsRequest), arg0) -} - -// DescribeVpcPeeringConnectionsWithContext mocks base method. -func (m *MockEC2) DescribeVpcPeeringConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcPeeringConnectionsWithContext indicates an expected call of DescribeVpcPeeringConnectionsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcPeeringConnectionsWithContext(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, "DescribeVpcPeeringConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...) -} - -// DescribeVpcs mocks base method. -func (m *MockEC2) DescribeVpcs(arg0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcs", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcs indicates an expected call of DescribeVpcs. -func (mr *MockEC2MockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2)(nil).DescribeVpcs), arg0) -} - -// DescribeVpcsPages mocks base method. -func (m *MockEC2) DescribeVpcsPages(arg0 *ec2.DescribeVpcsInput, arg1 func(*ec2.DescribeVpcsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcsPages indicates an expected call of DescribeVpcsPages. -func (mr *MockEC2MockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2)(nil).DescribeVpcsPages), arg0, arg1) -} - -// DescribeVpcsPagesWithContext mocks base method. -func (m *MockEC2) DescribeVpcsPagesWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 func(*ec2.DescribeVpcsOutput, 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, "DescribeVpcsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeVpcsPagesWithContext indicates an expected call of DescribeVpcsPagesWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcsPagesWithContext(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, "DescribeVpcsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcsPagesWithContext), varargs...) -} - -// DescribeVpcsRequest mocks base method. -func (m *MockEC2) DescribeVpcsRequest(arg0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpcsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpcsOutput) - return ret0, ret1 -} - -// DescribeVpcsRequest indicates an expected call of DescribeVpcsRequest. -func (mr *MockEC2MockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpcsRequest), arg0) -} - -// DescribeVpcsWithContext mocks base method. -func (m *MockEC2) DescribeVpcsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.Option) (*ec2.DescribeVpcsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpcsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpcsWithContext indicates an expected call of DescribeVpcsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpcsWithContext(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, "DescribeVpcsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpcsWithContext), varargs...) -} - -// DescribeVpnConnections mocks base method. -func (m *MockEC2) DescribeVpnConnections(arg0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpnConnections", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpnConnections indicates an expected call of DescribeVpnConnections. -func (mr *MockEC2MockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2)(nil).DescribeVpnConnections), arg0) -} - -// DescribeVpnConnectionsRequest mocks base method. -func (m *MockEC2) DescribeVpnConnectionsRequest(arg0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpnConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpnConnectionsOutput) - return ret0, ret1 -} - -// DescribeVpnConnectionsRequest indicates an expected call of DescribeVpnConnectionsRequest. -func (mr *MockEC2MockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpnConnectionsRequest), arg0) -} - -// DescribeVpnConnectionsWithContext mocks base method. -func (m *MockEC2) DescribeVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpnConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpnConnectionsWithContext indicates an expected call of DescribeVpnConnectionsWithContext. -func (mr *MockEC2MockRecorder) DescribeVpnConnectionsWithContext(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, "DescribeVpnConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpnConnectionsWithContext), varargs...) -} - -// DescribeVpnGateways mocks base method. -func (m *MockEC2) DescribeVpnGateways(arg0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpnGateways", arg0) - ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpnGateways indicates an expected call of DescribeVpnGateways. -func (mr *MockEC2MockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2)(nil).DescribeVpnGateways), arg0) -} - -// DescribeVpnGatewaysRequest mocks base method. -func (m *MockEC2) DescribeVpnGatewaysRequest(arg0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeVpnGatewaysRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DescribeVpnGatewaysOutput) - return ret0, ret1 -} - -// DescribeVpnGatewaysRequest indicates an expected call of DescribeVpnGatewaysRequest. -func (mr *MockEC2MockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2)(nil).DescribeVpnGatewaysRequest), arg0) -} - -// DescribeVpnGatewaysWithContext mocks base method. -func (m *MockEC2) DescribeVpnGatewaysWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnGatewaysInput, arg2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeVpnGatewaysWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeVpnGatewaysWithContext indicates an expected call of DescribeVpnGatewaysWithContext. -func (mr *MockEC2MockRecorder) DescribeVpnGatewaysWithContext(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, "DescribeVpnGatewaysWithContext", reflect.TypeOf((*MockEC2)(nil).DescribeVpnGatewaysWithContext), varargs...) -} - -// DetachClassicLinkVpc mocks base method. -func (m *MockEC2) DetachClassicLinkVpc(arg0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachClassicLinkVpc", arg0) - ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachClassicLinkVpc indicates an expected call of DetachClassicLinkVpc. -func (mr *MockEC2MockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2)(nil).DetachClassicLinkVpc), arg0) -} - -// DetachClassicLinkVpcRequest mocks base method. -func (m *MockEC2) DetachClassicLinkVpcRequest(arg0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachClassicLinkVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DetachClassicLinkVpcOutput) - return ret0, ret1 -} - -// DetachClassicLinkVpcRequest indicates an expected call of DetachClassicLinkVpcRequest. -func (mr *MockEC2MockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2)(nil).DetachClassicLinkVpcRequest), arg0) -} - -// DetachClassicLinkVpcWithContext mocks base method. -func (m *MockEC2) DetachClassicLinkVpcWithContext(arg0 context.Context, arg1 *ec2.DetachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachClassicLinkVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachClassicLinkVpcWithContext indicates an expected call of DetachClassicLinkVpcWithContext. -func (mr *MockEC2MockRecorder) DetachClassicLinkVpcWithContext(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, "DetachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2)(nil).DetachClassicLinkVpcWithContext), varargs...) -} - -// DetachInternetGateway mocks base method. -func (m *MockEC2) DetachInternetGateway(arg0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachInternetGateway", arg0) - ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachInternetGateway indicates an expected call of DetachInternetGateway. -func (mr *MockEC2MockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2)(nil).DetachInternetGateway), arg0) -} - -// DetachInternetGatewayRequest mocks base method. -func (m *MockEC2) DetachInternetGatewayRequest(arg0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachInternetGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DetachInternetGatewayOutput) - return ret0, ret1 -} - -// DetachInternetGatewayRequest indicates an expected call of DetachInternetGatewayRequest. -func (mr *MockEC2MockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DetachInternetGatewayRequest), arg0) -} - -// DetachInternetGatewayWithContext mocks base method. -func (m *MockEC2) DetachInternetGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...request.Option) (*ec2.DetachInternetGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachInternetGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachInternetGatewayWithContext indicates an expected call of DetachInternetGatewayWithContext. -func (mr *MockEC2MockRecorder) DetachInternetGatewayWithContext(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, "DetachInternetGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DetachInternetGatewayWithContext), varargs...) -} - -// DetachNetworkInterface mocks base method. -func (m *MockEC2) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0) - ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachNetworkInterface indicates an expected call of DetachNetworkInterface. -func (mr *MockEC2MockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2)(nil).DetachNetworkInterface), arg0) -} - -// DetachNetworkInterfaceRequest mocks base method. -func (m *MockEC2) DetachNetworkInterfaceRequest(arg0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachNetworkInterfaceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DetachNetworkInterfaceOutput) - return ret0, ret1 -} - -// DetachNetworkInterfaceRequest indicates an expected call of DetachNetworkInterfaceRequest. -func (mr *MockEC2MockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).DetachNetworkInterfaceRequest), arg0) -} - -// DetachNetworkInterfaceWithContext mocks base method. -func (m *MockEC2) DetachNetworkInterfaceWithContext(arg0 context.Context, arg1 *ec2.DetachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachNetworkInterfaceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachNetworkInterfaceWithContext indicates an expected call of DetachNetworkInterfaceWithContext. -func (mr *MockEC2MockRecorder) DetachNetworkInterfaceWithContext(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, "DetachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2)(nil).DetachNetworkInterfaceWithContext), varargs...) -} - -// DetachVerifiedAccessTrustProvider mocks base method. -func (m *MockEC2) DetachVerifiedAccessTrustProvider(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProvider", arg0) - ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVerifiedAccessTrustProvider indicates an expected call of DetachVerifiedAccessTrustProvider. -func (mr *MockEC2MockRecorder) DetachVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2)(nil).DetachVerifiedAccessTrustProvider), arg0) -} - -// DetachVerifiedAccessTrustProviderRequest mocks base method. -func (m *MockEC2) DetachVerifiedAccessTrustProviderRequest(arg0 *ec2.DetachVerifiedAccessTrustProviderInput) (*request.Request, *ec2.DetachVerifiedAccessTrustProviderOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DetachVerifiedAccessTrustProviderOutput) - return ret0, ret1 -} - -// DetachVerifiedAccessTrustProviderRequest indicates an expected call of DetachVerifiedAccessTrustProviderRequest. -func (mr *MockEC2MockRecorder) DetachVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2)(nil).DetachVerifiedAccessTrustProviderRequest), arg0) -} - -// DetachVerifiedAccessTrustProviderWithContext mocks base method. -func (m *MockEC2) DetachVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.DetachVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.DetachVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachVerifiedAccessTrustProviderWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DetachVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVerifiedAccessTrustProviderWithContext indicates an expected call of DetachVerifiedAccessTrustProviderWithContext. -func (mr *MockEC2MockRecorder) DetachVerifiedAccessTrustProviderWithContext(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, "DetachVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2)(nil).DetachVerifiedAccessTrustProviderWithContext), varargs...) -} - -// DetachVolume mocks base method. -func (m *MockEC2) DetachVolume(arg0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVolume", arg0) - ret0, _ := ret[0].(*ec2.VolumeAttachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVolume indicates an expected call of DetachVolume. -func (mr *MockEC2MockRecorder) DetachVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2)(nil).DetachVolume), arg0) -} - -// DetachVolumeRequest mocks base method. -func (m *MockEC2) DetachVolumeRequest(arg0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.VolumeAttachment) - return ret0, ret1 -} - -// DetachVolumeRequest indicates an expected call of DetachVolumeRequest. -func (mr *MockEC2MockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2)(nil).DetachVolumeRequest), arg0) -} - -// DetachVolumeWithContext mocks base method. -func (m *MockEC2) DetachVolumeWithContext(arg0 context.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.VolumeAttachment) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVolumeWithContext indicates an expected call of DetachVolumeWithContext. -func (mr *MockEC2MockRecorder) DetachVolumeWithContext(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, "DetachVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).DetachVolumeWithContext), varargs...) -} - -// DetachVpnGateway mocks base method. -func (m *MockEC2) DetachVpnGateway(arg0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVpnGateway", arg0) - ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVpnGateway indicates an expected call of DetachVpnGateway. -func (mr *MockEC2MockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2)(nil).DetachVpnGateway), arg0) -} - -// DetachVpnGatewayRequest mocks base method. -func (m *MockEC2) DetachVpnGatewayRequest(arg0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DetachVpnGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DetachVpnGatewayOutput) - return ret0, ret1 -} - -// DetachVpnGatewayRequest indicates an expected call of DetachVpnGatewayRequest. -func (mr *MockEC2MockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2)(nil).DetachVpnGatewayRequest), arg0) -} - -// DetachVpnGatewayWithContext mocks base method. -func (m *MockEC2) DetachVpnGatewayWithContext(arg0 context.Context, arg1 *ec2.DetachVpnGatewayInput, arg2 ...request.Option) (*ec2.DetachVpnGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DetachVpnGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DetachVpnGatewayWithContext indicates an expected call of DetachVpnGatewayWithContext. -func (mr *MockEC2MockRecorder) DetachVpnGatewayWithContext(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, "DetachVpnGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).DetachVpnGatewayWithContext), varargs...) -} - -// DisableAddressTransfer mocks base method. -func (m *MockEC2) DisableAddressTransfer(arg0 *ec2.DisableAddressTransferInput) (*ec2.DisableAddressTransferOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableAddressTransfer", arg0) - ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableAddressTransfer indicates an expected call of DisableAddressTransfer. -func (mr *MockEC2MockRecorder) DisableAddressTransfer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransfer", reflect.TypeOf((*MockEC2)(nil).DisableAddressTransfer), arg0) -} - -// DisableAddressTransferRequest mocks base method. -func (m *MockEC2) DisableAddressTransferRequest(arg0 *ec2.DisableAddressTransferInput) (*request.Request, *ec2.DisableAddressTransferOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableAddressTransferRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableAddressTransferOutput) - return ret0, ret1 -} - -// DisableAddressTransferRequest indicates an expected call of DisableAddressTransferRequest. -func (mr *MockEC2MockRecorder) DisableAddressTransferRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAddressTransferRequest", reflect.TypeOf((*MockEC2)(nil).DisableAddressTransferRequest), arg0) -} - -// DisableAddressTransferWithContext mocks base method. -func (m *MockEC2) DisableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.DisableAddressTransferInput, arg2 ...request.Option) (*ec2.DisableAddressTransferOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableAddressTransferWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableAddressTransferWithContext indicates an expected call of DisableAddressTransferWithContext. -func (mr *MockEC2MockRecorder) DisableAddressTransferWithContext(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, "DisableAddressTransferWithContext", reflect.TypeOf((*MockEC2)(nil).DisableAddressTransferWithContext), varargs...) -} - -// DisableAwsNetworkPerformanceMetricSubscription mocks base method. -func (m *MockEC2) DisableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscription", arg0) - ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableAwsNetworkPerformanceMetricSubscription indicates an expected call of DisableAwsNetworkPerformanceMetricSubscription. -func (mr *MockEC2MockRecorder) DisableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2)(nil).DisableAwsNetworkPerformanceMetricSubscription), arg0) -} - -// DisableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method. -func (m *MockEC2) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) - return ret0, ret1 -} - -// DisableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of DisableAwsNetworkPerformanceMetricSubscriptionRequest. -func (mr *MockEC2MockRecorder) DisableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2)(nil).DisableAwsNetworkPerformanceMetricSubscriptionRequest), arg0) -} - -// DisableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method. -func (m *MockEC2) DisableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.DisableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableAwsNetworkPerformanceMetricSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableAwsNetworkPerformanceMetricSubscriptionWithContext indicates an expected call of DisableAwsNetworkPerformanceMetricSubscriptionWithContext. -func (mr *MockEC2MockRecorder) DisableAwsNetworkPerformanceMetricSubscriptionWithContext(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, "DisableAwsNetworkPerformanceMetricSubscriptionWithContext", reflect.TypeOf((*MockEC2)(nil).DisableAwsNetworkPerformanceMetricSubscriptionWithContext), varargs...) -} - -// DisableEbsEncryptionByDefault mocks base method. -func (m *MockEC2) DisableEbsEncryptionByDefault(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefault", arg0) - ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableEbsEncryptionByDefault indicates an expected call of DisableEbsEncryptionByDefault. -func (mr *MockEC2MockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2)(nil).DisableEbsEncryptionByDefault), arg0) -} - -// DisableEbsEncryptionByDefaultRequest mocks base method. -func (m *MockEC2) DisableEbsEncryptionByDefaultRequest(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableEbsEncryptionByDefaultOutput) - return ret0, ret1 -} - -// DisableEbsEncryptionByDefaultRequest indicates an expected call of DisableEbsEncryptionByDefaultRequest. -func (mr *MockEC2MockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2)(nil).DisableEbsEncryptionByDefaultRequest), arg0) -} - -// DisableEbsEncryptionByDefaultWithContext mocks base method. -func (m *MockEC2) DisableEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.DisableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableEbsEncryptionByDefaultWithContext indicates an expected call of DisableEbsEncryptionByDefaultWithContext. -func (mr *MockEC2MockRecorder) DisableEbsEncryptionByDefaultWithContext(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, "DisableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2)(nil).DisableEbsEncryptionByDefaultWithContext), varargs...) -} - -// DisableFastLaunch mocks base method. -func (m *MockEC2) DisableFastLaunch(arg0 *ec2.DisableFastLaunchInput) (*ec2.DisableFastLaunchOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableFastLaunch", arg0) - ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableFastLaunch indicates an expected call of DisableFastLaunch. -func (mr *MockEC2MockRecorder) DisableFastLaunch(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunch", reflect.TypeOf((*MockEC2)(nil).DisableFastLaunch), arg0) -} - -// DisableFastLaunchRequest mocks base method. -func (m *MockEC2) DisableFastLaunchRequest(arg0 *ec2.DisableFastLaunchInput) (*request.Request, *ec2.DisableFastLaunchOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableFastLaunchRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableFastLaunchOutput) - return ret0, ret1 -} - -// DisableFastLaunchRequest indicates an expected call of DisableFastLaunchRequest. -func (mr *MockEC2MockRecorder) DisableFastLaunchRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastLaunchRequest", reflect.TypeOf((*MockEC2)(nil).DisableFastLaunchRequest), arg0) -} - -// DisableFastLaunchWithContext mocks base method. -func (m *MockEC2) DisableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.DisableFastLaunchInput, arg2 ...request.Option) (*ec2.DisableFastLaunchOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableFastLaunchWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableFastLaunchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableFastLaunchWithContext indicates an expected call of DisableFastLaunchWithContext. -func (mr *MockEC2MockRecorder) DisableFastLaunchWithContext(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, "DisableFastLaunchWithContext", reflect.TypeOf((*MockEC2)(nil).DisableFastLaunchWithContext), varargs...) -} - -// DisableFastSnapshotRestores mocks base method. -func (m *MockEC2) DisableFastSnapshotRestores(arg0 *ec2.DisableFastSnapshotRestoresInput) (*ec2.DisableFastSnapshotRestoresOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableFastSnapshotRestores", arg0) - ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableFastSnapshotRestores indicates an expected call of DisableFastSnapshotRestores. -func (mr *MockEC2MockRecorder) DisableFastSnapshotRestores(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestores", reflect.TypeOf((*MockEC2)(nil).DisableFastSnapshotRestores), arg0) -} - -// DisableFastSnapshotRestoresRequest mocks base method. -func (m *MockEC2) DisableFastSnapshotRestoresRequest(arg0 *ec2.DisableFastSnapshotRestoresInput) (*request.Request, *ec2.DisableFastSnapshotRestoresOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableFastSnapshotRestoresOutput) - return ret0, ret1 -} - -// DisableFastSnapshotRestoresRequest indicates an expected call of DisableFastSnapshotRestoresRequest. -func (mr *MockEC2MockRecorder) DisableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2)(nil).DisableFastSnapshotRestoresRequest), arg0) -} - -// DisableFastSnapshotRestoresWithContext mocks base method. -func (m *MockEC2) DisableFastSnapshotRestoresWithContext(arg0 context.Context, arg1 *ec2.DisableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.DisableFastSnapshotRestoresOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableFastSnapshotRestoresWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableFastSnapshotRestoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableFastSnapshotRestoresWithContext indicates an expected call of DisableFastSnapshotRestoresWithContext. -func (mr *MockEC2MockRecorder) DisableFastSnapshotRestoresWithContext(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, "DisableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2)(nil).DisableFastSnapshotRestoresWithContext), varargs...) -} - -// DisableImage mocks base method. -func (m *MockEC2) DisableImage(arg0 *ec2.DisableImageInput) (*ec2.DisableImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableImage", arg0) - ret0, _ := ret[0].(*ec2.DisableImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableImage indicates an expected call of DisableImage. -func (mr *MockEC2MockRecorder) DisableImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImage", reflect.TypeOf((*MockEC2)(nil).DisableImage), arg0) -} - -// DisableImageBlockPublicAccess mocks base method. -func (m *MockEC2) DisableImageBlockPublicAccess(arg0 *ec2.DisableImageBlockPublicAccessInput) (*ec2.DisableImageBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableImageBlockPublicAccess", arg0) - ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableImageBlockPublicAccess indicates an expected call of DisableImageBlockPublicAccess. -func (mr *MockEC2MockRecorder) DisableImageBlockPublicAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccess", reflect.TypeOf((*MockEC2)(nil).DisableImageBlockPublicAccess), arg0) -} - -// DisableImageBlockPublicAccessRequest mocks base method. -func (m *MockEC2) DisableImageBlockPublicAccessRequest(arg0 *ec2.DisableImageBlockPublicAccessInput) (*request.Request, *ec2.DisableImageBlockPublicAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableImageBlockPublicAccessOutput) - return ret0, ret1 -} - -// DisableImageBlockPublicAccessRequest indicates an expected call of DisableImageBlockPublicAccessRequest. -func (mr *MockEC2MockRecorder) DisableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2)(nil).DisableImageBlockPublicAccessRequest), arg0) -} - -// DisableImageBlockPublicAccessWithContext mocks base method. -func (m *MockEC2) DisableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableImageBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableImageBlockPublicAccessWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableImageBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableImageBlockPublicAccessWithContext indicates an expected call of DisableImageBlockPublicAccessWithContext. -func (mr *MockEC2MockRecorder) DisableImageBlockPublicAccessWithContext(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, "DisableImageBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2)(nil).DisableImageBlockPublicAccessWithContext), varargs...) -} - -// DisableImageDeprecation mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisableImageDeprecation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecation", reflect.TypeOf((*MockEC2)(nil).DisableImageDeprecation), arg0) -} - -// DisableImageDeprecationRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisableImageDeprecationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageDeprecationRequest", reflect.TypeOf((*MockEC2)(nil).DisableImageDeprecationRequest), arg0) -} - -// DisableImageDeprecationWithContext mocks base method. -func (m *MockEC2) DisableImageDeprecationWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisableImageDeprecationWithContext), varargs...) -} - -// DisableImageRequest mocks base method. -func (m *MockEC2) DisableImageRequest(arg0 *ec2.DisableImageInput) (*request.Request, *ec2.DisableImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableImageOutput) - return ret0, ret1 -} - -// DisableImageRequest indicates an expected call of DisableImageRequest. -func (mr *MockEC2MockRecorder) DisableImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableImageRequest", reflect.TypeOf((*MockEC2)(nil).DisableImageRequest), arg0) -} - -// DisableImageWithContext mocks base method. -func (m *MockEC2) DisableImageWithContext(arg0 context.Context, arg1 *ec2.DisableImageInput, arg2 ...request.Option) (*ec2.DisableImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableImageWithContext indicates an expected call of DisableImageWithContext. -func (mr *MockEC2MockRecorder) DisableImageWithContext(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, "DisableImageWithContext", reflect.TypeOf((*MockEC2)(nil).DisableImageWithContext), varargs...) -} - -// DisableIpamOrganizationAdminAccount mocks base method. -func (m *MockEC2) DisableIpamOrganizationAdminAccount(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccount", arg0) - ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableIpamOrganizationAdminAccount indicates an expected call of DisableIpamOrganizationAdminAccount. -func (mr *MockEC2MockRecorder) DisableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2)(nil).DisableIpamOrganizationAdminAccount), arg0) -} - -// DisableIpamOrganizationAdminAccountRequest mocks base method. -func (m *MockEC2) DisableIpamOrganizationAdminAccountRequest(arg0 *ec2.DisableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.DisableIpamOrganizationAdminAccountOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableIpamOrganizationAdminAccountOutput) - return ret0, ret1 -} - -// DisableIpamOrganizationAdminAccountRequest indicates an expected call of DisableIpamOrganizationAdminAccountRequest. -func (mr *MockEC2MockRecorder) DisableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2)(nil).DisableIpamOrganizationAdminAccountRequest), arg0) -} - -// DisableIpamOrganizationAdminAccountWithContext mocks base method. -func (m *MockEC2) DisableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.DisableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.DisableIpamOrganizationAdminAccountOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableIpamOrganizationAdminAccountWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableIpamOrganizationAdminAccountOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableIpamOrganizationAdminAccountWithContext indicates an expected call of DisableIpamOrganizationAdminAccountWithContext. -func (mr *MockEC2MockRecorder) DisableIpamOrganizationAdminAccountWithContext(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, "DisableIpamOrganizationAdminAccountWithContext", reflect.TypeOf((*MockEC2)(nil).DisableIpamOrganizationAdminAccountWithContext), varargs...) -} - -// DisableSerialConsoleAccess mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisableSerialConsoleAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccess", reflect.TypeOf((*MockEC2)(nil).DisableSerialConsoleAccess), arg0) -} - -// DisableSerialConsoleAccessRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2)(nil).DisableSerialConsoleAccessRequest), arg0) -} - -// DisableSerialConsoleAccessWithContext mocks base method. -func (m *MockEC2) DisableSerialConsoleAccessWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisableSerialConsoleAccessWithContext), varargs...) -} - -// DisableSnapshotBlockPublicAccess mocks base method. -func (m *MockEC2) DisableSnapshotBlockPublicAccess(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccess", arg0) - ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableSnapshotBlockPublicAccess indicates an expected call of DisableSnapshotBlockPublicAccess. -func (mr *MockEC2MockRecorder) DisableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2)(nil).DisableSnapshotBlockPublicAccess), arg0) -} - -// DisableSnapshotBlockPublicAccessRequest mocks base method. -func (m *MockEC2) DisableSnapshotBlockPublicAccessRequest(arg0 *ec2.DisableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.DisableSnapshotBlockPublicAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableSnapshotBlockPublicAccessOutput) - return ret0, ret1 -} - -// DisableSnapshotBlockPublicAccessRequest indicates an expected call of DisableSnapshotBlockPublicAccessRequest. -func (mr *MockEC2MockRecorder) DisableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2)(nil).DisableSnapshotBlockPublicAccessRequest), arg0) -} - -// DisableSnapshotBlockPublicAccessWithContext mocks base method. -func (m *MockEC2) DisableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.DisableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.DisableSnapshotBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableSnapshotBlockPublicAccessWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableSnapshotBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableSnapshotBlockPublicAccessWithContext indicates an expected call of DisableSnapshotBlockPublicAccessWithContext. -func (mr *MockEC2MockRecorder) DisableSnapshotBlockPublicAccessWithContext(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, "DisableSnapshotBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2)(nil).DisableSnapshotBlockPublicAccessWithContext), varargs...) -} - -// DisableTransitGatewayRouteTablePropagation mocks base method. -func (m *MockEC2) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagation", arg0) - ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableTransitGatewayRouteTablePropagation indicates an expected call of DisableTransitGatewayRouteTablePropagation. -func (mr *MockEC2MockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2)(nil).DisableTransitGatewayRouteTablePropagation), arg0) -} - -// DisableTransitGatewayRouteTablePropagationRequest mocks base method. -func (m *MockEC2) DisableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) - return ret0, ret1 -} - -// DisableTransitGatewayRouteTablePropagationRequest indicates an expected call of DisableTransitGatewayRouteTablePropagationRequest. -func (mr *MockEC2MockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0) -} - -// DisableTransitGatewayRouteTablePropagationWithContext mocks base method. -func (m *MockEC2) DisableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableTransitGatewayRouteTablePropagationWithContext indicates an expected call of DisableTransitGatewayRouteTablePropagationWithContext. -func (mr *MockEC2MockRecorder) DisableTransitGatewayRouteTablePropagationWithContext(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, "DisableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2)(nil).DisableTransitGatewayRouteTablePropagationWithContext), varargs...) -} - -// DisableVgwRoutePropagation mocks base method. -func (m *MockEC2) DisableVgwRoutePropagation(arg0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVgwRoutePropagation", arg0) - ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVgwRoutePropagation indicates an expected call of DisableVgwRoutePropagation. -func (mr *MockEC2MockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2)(nil).DisableVgwRoutePropagation), arg0) -} - -// DisableVgwRoutePropagationRequest mocks base method. -func (m *MockEC2) DisableVgwRoutePropagationRequest(arg0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVgwRoutePropagationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableVgwRoutePropagationOutput) - return ret0, ret1 -} - -// DisableVgwRoutePropagationRequest indicates an expected call of DisableVgwRoutePropagationRequest. -func (mr *MockEC2MockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2)(nil).DisableVgwRoutePropagationRequest), arg0) -} - -// DisableVgwRoutePropagationWithContext mocks base method. -func (m *MockEC2) DisableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.DisableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableVgwRoutePropagationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVgwRoutePropagationWithContext indicates an expected call of DisableVgwRoutePropagationWithContext. -func (mr *MockEC2MockRecorder) DisableVgwRoutePropagationWithContext(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, "DisableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2)(nil).DisableVgwRoutePropagationWithContext), varargs...) -} - -// DisableVpcClassicLink mocks base method. -func (m *MockEC2) DisableVpcClassicLink(arg0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVpcClassicLink", arg0) - ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVpcClassicLink indicates an expected call of DisableVpcClassicLink. -func (mr *MockEC2MockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLink), arg0) -} - -// DisableVpcClassicLinkDnsSupport mocks base method. -func (m *MockEC2) DisableVpcClassicLinkDnsSupport(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupport", arg0) - ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVpcClassicLinkDnsSupport indicates an expected call of DisableVpcClassicLinkDnsSupport. -func (mr *MockEC2MockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLinkDnsSupport), arg0) -} - -// DisableVpcClassicLinkDnsSupportRequest mocks base method. -func (m *MockEC2) DisableVpcClassicLinkDnsSupportRequest(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkDnsSupportOutput) - return ret0, ret1 -} - -// DisableVpcClassicLinkDnsSupportRequest indicates an expected call of DisableVpcClassicLinkDnsSupportRequest. -func (mr *MockEC2MockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0) -} - -// DisableVpcClassicLinkDnsSupportWithContext mocks base method. -func (m *MockEC2) DisableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVpcClassicLinkDnsSupportWithContext indicates an expected call of DisableVpcClassicLinkDnsSupportWithContext. -func (mr *MockEC2MockRecorder) DisableVpcClassicLinkDnsSupportWithContext(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, "DisableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLinkDnsSupportWithContext), varargs...) -} - -// DisableVpcClassicLinkRequest mocks base method. -func (m *MockEC2) DisableVpcClassicLinkRequest(arg0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableVpcClassicLinkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkOutput) - return ret0, ret1 -} - -// DisableVpcClassicLinkRequest indicates an expected call of DisableVpcClassicLinkRequest. -func (mr *MockEC2MockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLinkRequest), arg0) -} - -// DisableVpcClassicLinkWithContext mocks base method. -func (m *MockEC2) DisableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.DisableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableVpcClassicLinkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableVpcClassicLinkWithContext indicates an expected call of DisableVpcClassicLinkWithContext. -func (mr *MockEC2MockRecorder) DisableVpcClassicLinkWithContext(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, "DisableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2)(nil).DisableVpcClassicLinkWithContext), varargs...) -} - -// DisassociateAddress mocks base method. -func (m *MockEC2) DisassociateAddress(arg0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateAddress", arg0) - ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateAddress indicates an expected call of DisassociateAddress. -func (mr *MockEC2MockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2)(nil).DisassociateAddress), arg0) -} - -// DisassociateAddressRequest mocks base method. -func (m *MockEC2) DisassociateAddressRequest(arg0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateAddressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateAddressOutput) - return ret0, ret1 -} - -// DisassociateAddressRequest indicates an expected call of DisassociateAddressRequest. -func (mr *MockEC2MockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateAddressRequest), arg0) -} - -// DisassociateAddressWithContext mocks base method. -func (m *MockEC2) DisassociateAddressWithContext(arg0 context.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...request.Option) (*ec2.DisassociateAddressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateAddressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateAddressWithContext indicates an expected call of DisassociateAddressWithContext. -func (mr *MockEC2MockRecorder) DisassociateAddressWithContext(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, "DisassociateAddressWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateAddressWithContext), varargs...) -} - -// DisassociateClientVpnTargetNetwork mocks base method. -func (m *MockEC2) DisassociateClientVpnTargetNetwork(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetwork", arg0) - ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateClientVpnTargetNetwork indicates an expected call of DisassociateClientVpnTargetNetwork. -func (mr *MockEC2MockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2)(nil).DisassociateClientVpnTargetNetwork), arg0) -} - -// DisassociateClientVpnTargetNetworkRequest mocks base method. -func (m *MockEC2) DisassociateClientVpnTargetNetworkRequest(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateClientVpnTargetNetworkOutput) - return ret0, ret1 -} - -// DisassociateClientVpnTargetNetworkRequest indicates an expected call of DisassociateClientVpnTargetNetworkRequest. -func (mr *MockEC2MockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateClientVpnTargetNetworkRequest), arg0) -} - -// DisassociateClientVpnTargetNetworkWithContext mocks base method. -func (m *MockEC2) DisassociateClientVpnTargetNetworkWithContext(arg0 context.Context, arg1 *ec2.DisassociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateClientVpnTargetNetworkWithContext indicates an expected call of DisassociateClientVpnTargetNetworkWithContext. -func (mr *MockEC2MockRecorder) DisassociateClientVpnTargetNetworkWithContext(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, "DisassociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...) -} - -// DisassociateEnclaveCertificateIamRole mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateEnclaveCertificateIamRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRole", reflect.TypeOf((*MockEC2)(nil).DisassociateEnclaveCertificateIamRole), arg0) -} - -// DisassociateEnclaveCertificateIamRoleRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateEnclaveCertificateIamRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateEnclaveCertificateIamRoleRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateEnclaveCertificateIamRoleRequest), arg0) -} - -// DisassociateEnclaveCertificateIamRoleWithContext mocks base method. -func (m *MockEC2) DisassociateEnclaveCertificateIamRoleWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisassociateEnclaveCertificateIamRoleWithContext), varargs...) -} - -// DisassociateIamInstanceProfile mocks base method. -func (m *MockEC2) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIamInstanceProfile", arg0) - ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIamInstanceProfile indicates an expected call of DisassociateIamInstanceProfile. -func (mr *MockEC2MockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2)(nil).DisassociateIamInstanceProfile), arg0) -} - -// DisassociateIamInstanceProfileRequest mocks base method. -func (m *MockEC2) DisassociateIamInstanceProfileRequest(arg0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateIamInstanceProfileOutput) - return ret0, ret1 -} - -// DisassociateIamInstanceProfileRequest indicates an expected call of DisassociateIamInstanceProfileRequest. -func (mr *MockEC2MockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateIamInstanceProfileRequest), arg0) -} - -// DisassociateIamInstanceProfileWithContext mocks base method. -func (m *MockEC2) DisassociateIamInstanceProfileWithContext(arg0 context.Context, arg1 *ec2.DisassociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIamInstanceProfileWithContext indicates an expected call of DisassociateIamInstanceProfileWithContext. -func (mr *MockEC2MockRecorder) DisassociateIamInstanceProfileWithContext(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, "DisassociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateIamInstanceProfileWithContext), varargs...) -} - -// DisassociateInstanceEventWindow mocks base method. -func (m *MockEC2) DisassociateInstanceEventWindow(arg0 *ec2.DisassociateInstanceEventWindowInput) (*ec2.DisassociateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateInstanceEventWindow", arg0) - ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateInstanceEventWindow indicates an expected call of DisassociateInstanceEventWindow. -func (mr *MockEC2MockRecorder) DisassociateInstanceEventWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindow", reflect.TypeOf((*MockEC2)(nil).DisassociateInstanceEventWindow), arg0) -} - -// DisassociateInstanceEventWindowRequest mocks base method. -func (m *MockEC2) DisassociateInstanceEventWindowRequest(arg0 *ec2.DisassociateInstanceEventWindowInput) (*request.Request, *ec2.DisassociateInstanceEventWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateInstanceEventWindowOutput) - return ret0, ret1 -} - -// DisassociateInstanceEventWindowRequest indicates an expected call of DisassociateInstanceEventWindowRequest. -func (mr *MockEC2MockRecorder) DisassociateInstanceEventWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateInstanceEventWindowRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateInstanceEventWindowRequest), arg0) -} - -// DisassociateInstanceEventWindowWithContext mocks base method. -func (m *MockEC2) DisassociateInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.DisassociateInstanceEventWindowInput, arg2 ...request.Option) (*ec2.DisassociateInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateInstanceEventWindowWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateInstanceEventWindowWithContext indicates an expected call of DisassociateInstanceEventWindowWithContext. -func (mr *MockEC2MockRecorder) DisassociateInstanceEventWindowWithContext(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, "DisassociateInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateInstanceEventWindowWithContext), varargs...) -} - -// DisassociateIpamByoasn mocks base method. -func (m *MockEC2) DisassociateIpamByoasn(arg0 *ec2.DisassociateIpamByoasnInput) (*ec2.DisassociateIpamByoasnOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIpamByoasn", arg0) - ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIpamByoasn indicates an expected call of DisassociateIpamByoasn. -func (mr *MockEC2MockRecorder) DisassociateIpamByoasn(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasn", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamByoasn), arg0) -} - -// DisassociateIpamByoasnRequest mocks base method. -func (m *MockEC2) DisassociateIpamByoasnRequest(arg0 *ec2.DisassociateIpamByoasnInput) (*request.Request, *ec2.DisassociateIpamByoasnOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIpamByoasnRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateIpamByoasnOutput) - return ret0, ret1 -} - -// DisassociateIpamByoasnRequest indicates an expected call of DisassociateIpamByoasnRequest. -func (mr *MockEC2MockRecorder) DisassociateIpamByoasnRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamByoasnRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamByoasnRequest), arg0) -} - -// DisassociateIpamByoasnWithContext mocks base method. -func (m *MockEC2) DisassociateIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamByoasnInput, arg2 ...request.Option) (*ec2.DisassociateIpamByoasnOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateIpamByoasnWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIpamByoasnWithContext indicates an expected call of DisassociateIpamByoasnWithContext. -func (mr *MockEC2MockRecorder) DisassociateIpamByoasnWithContext(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, "DisassociateIpamByoasnWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamByoasnWithContext), varargs...) -} - -// DisassociateIpamResourceDiscovery mocks base method. -func (m *MockEC2) DisassociateIpamResourceDiscovery(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscovery", arg0) - ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIpamResourceDiscovery indicates an expected call of DisassociateIpamResourceDiscovery. -func (mr *MockEC2MockRecorder) DisassociateIpamResourceDiscovery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscovery", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamResourceDiscovery), arg0) -} - -// DisassociateIpamResourceDiscoveryRequest mocks base method. -func (m *MockEC2) DisassociateIpamResourceDiscoveryRequest(arg0 *ec2.DisassociateIpamResourceDiscoveryInput) (*request.Request, *ec2.DisassociateIpamResourceDiscoveryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateIpamResourceDiscoveryOutput) - return ret0, ret1 -} - -// DisassociateIpamResourceDiscoveryRequest indicates an expected call of DisassociateIpamResourceDiscoveryRequest. -func (mr *MockEC2MockRecorder) DisassociateIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamResourceDiscoveryRequest), arg0) -} - -// DisassociateIpamResourceDiscoveryWithContext mocks base method. -func (m *MockEC2) DisassociateIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.DisassociateIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.DisassociateIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateIpamResourceDiscoveryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateIpamResourceDiscoveryWithContext indicates an expected call of DisassociateIpamResourceDiscoveryWithContext. -func (mr *MockEC2MockRecorder) DisassociateIpamResourceDiscoveryWithContext(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, "DisassociateIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateIpamResourceDiscoveryWithContext), varargs...) -} - -// DisassociateNatGatewayAddress mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateNatGatewayAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddress", reflect.TypeOf((*MockEC2)(nil).DisassociateNatGatewayAddress), arg0) -} - -// DisassociateNatGatewayAddressRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateNatGatewayAddressRequest), arg0) -} - -// DisassociateNatGatewayAddressWithContext mocks base method. -func (m *MockEC2) DisassociateNatGatewayAddressWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisassociateNatGatewayAddressWithContext), varargs...) -} - -// DisassociateRouteTable mocks base method. -func (m *MockEC2) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateRouteTable", arg0) - ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateRouteTable indicates an expected call of DisassociateRouteTable. -func (mr *MockEC2MockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2)(nil).DisassociateRouteTable), arg0) -} - -// DisassociateRouteTableRequest mocks base method. -func (m *MockEC2) DisassociateRouteTableRequest(arg0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateRouteTableOutput) - return ret0, ret1 -} - -// DisassociateRouteTableRequest indicates an expected call of DisassociateRouteTableRequest. -func (mr *MockEC2MockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateRouteTableRequest), arg0) -} - -// DisassociateRouteTableWithContext mocks base method. -func (m *MockEC2) DisassociateRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateRouteTableWithContext indicates an expected call of DisassociateRouteTableWithContext. -func (mr *MockEC2MockRecorder) DisassociateRouteTableWithContext(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, "DisassociateRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateRouteTableWithContext), varargs...) -} - -// DisassociateSubnetCidrBlock mocks base method. -func (m *MockEC2) DisassociateSubnetCidrBlock(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlock", arg0) - ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateSubnetCidrBlock indicates an expected call of DisassociateSubnetCidrBlock. -func (mr *MockEC2MockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2)(nil).DisassociateSubnetCidrBlock), arg0) -} - -// DisassociateSubnetCidrBlockRequest mocks base method. -func (m *MockEC2) DisassociateSubnetCidrBlockRequest(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateSubnetCidrBlockOutput) - return ret0, ret1 -} - -// DisassociateSubnetCidrBlockRequest indicates an expected call of DisassociateSubnetCidrBlockRequest. -func (mr *MockEC2MockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateSubnetCidrBlockRequest), arg0) -} - -// DisassociateSubnetCidrBlockWithContext mocks base method. -func (m *MockEC2) DisassociateSubnetCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateSubnetCidrBlockWithContext indicates an expected call of DisassociateSubnetCidrBlockWithContext. -func (mr *MockEC2MockRecorder) DisassociateSubnetCidrBlockWithContext(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, "DisassociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateSubnetCidrBlockWithContext), varargs...) -} - -// DisassociateTransitGatewayMulticastDomain mocks base method. -func (m *MockEC2) DisassociateTransitGatewayMulticastDomain(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomain", arg0) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayMulticastDomain indicates an expected call of DisassociateTransitGatewayMulticastDomain. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayMulticastDomain), arg0) -} - -// DisassociateTransitGatewayMulticastDomainRequest mocks base method. -func (m *MockEC2) DisassociateTransitGatewayMulticastDomainRequest(arg0 *ec2.DisassociateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.DisassociateTransitGatewayMulticastDomainOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) - return ret0, ret1 -} - -// DisassociateTransitGatewayMulticastDomainRequest indicates an expected call of DisassociateTransitGatewayMulticastDomainRequest. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayMulticastDomainRequest), arg0) -} - -// DisassociateTransitGatewayMulticastDomainWithContext mocks base method. -func (m *MockEC2) DisassociateTransitGatewayMulticastDomainWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayMulticastDomainOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateTransitGatewayMulticastDomainWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayMulticastDomainOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayMulticastDomainWithContext indicates an expected call of DisassociateTransitGatewayMulticastDomainWithContext. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayMulticastDomainWithContext(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, "DisassociateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayMulticastDomainWithContext), varargs...) -} - -// DisassociateTransitGatewayPolicyTable mocks base method. -func (m *MockEC2) DisassociateTransitGatewayPolicyTable(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTable", arg0) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayPolicyTable indicates an expected call of DisassociateTransitGatewayPolicyTable. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayPolicyTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTable", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayPolicyTable), arg0) -} - -// DisassociateTransitGatewayPolicyTableRequest mocks base method. -func (m *MockEC2) DisassociateTransitGatewayPolicyTableRequest(arg0 *ec2.DisassociateTransitGatewayPolicyTableInput) (*request.Request, *ec2.DisassociateTransitGatewayPolicyTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayPolicyTableOutput) - return ret0, ret1 -} - -// DisassociateTransitGatewayPolicyTableRequest indicates an expected call of DisassociateTransitGatewayPolicyTableRequest. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayPolicyTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayPolicyTableRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayPolicyTableRequest), arg0) -} - -// DisassociateTransitGatewayPolicyTableWithContext mocks base method. -func (m *MockEC2) DisassociateTransitGatewayPolicyTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayPolicyTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayPolicyTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateTransitGatewayPolicyTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayPolicyTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayPolicyTableWithContext indicates an expected call of DisassociateTransitGatewayPolicyTableWithContext. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayPolicyTableWithContext(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, "DisassociateTransitGatewayPolicyTableWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayPolicyTableWithContext), varargs...) -} - -// DisassociateTransitGatewayRouteTable mocks base method. -func (m *MockEC2) DisassociateTransitGatewayRouteTable(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTable", arg0) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayRouteTable indicates an expected call of DisassociateTransitGatewayRouteTable. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayRouteTable), arg0) -} - -// DisassociateTransitGatewayRouteTableRequest mocks base method. -func (m *MockEC2) DisassociateTransitGatewayRouteTableRequest(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayRouteTableOutput) - return ret0, ret1 -} - -// DisassociateTransitGatewayRouteTableRequest indicates an expected call of DisassociateTransitGatewayRouteTableRequest. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayRouteTableRequest), arg0) -} - -// DisassociateTransitGatewayRouteTableWithContext mocks base method. -func (m *MockEC2) DisassociateTransitGatewayRouteTableWithContext(arg0 context.Context, arg1 *ec2.DisassociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableWithContext", varargs...) - ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateTransitGatewayRouteTableWithContext indicates an expected call of DisassociateTransitGatewayRouteTableWithContext. -func (mr *MockEC2MockRecorder) DisassociateTransitGatewayRouteTableWithContext(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, "DisassociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...) -} - -// DisassociateTrunkInterface mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateTrunkInterface(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterface", reflect.TypeOf((*MockEC2)(nil).DisassociateTrunkInterface), arg0) -} - -// DisassociateTrunkInterfaceRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) DisassociateTrunkInterfaceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTrunkInterfaceRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateTrunkInterfaceRequest), arg0) -} - -// DisassociateTrunkInterfaceWithContext mocks base method. -func (m *MockEC2) DisassociateTrunkInterfaceWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisassociateTrunkInterfaceWithContext), varargs...) -} - -// DisassociateVpcCidrBlock mocks base method. -func (m *MockEC2) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", arg0) - ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock. -func (mr *MockEC2MockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2)(nil).DisassociateVpcCidrBlock), arg0) -} - -// DisassociateVpcCidrBlockRequest mocks base method. -func (m *MockEC2) DisassociateVpcCidrBlockRequest(arg0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.DisassociateVpcCidrBlockOutput) - return ret0, ret1 -} - -// DisassociateVpcCidrBlockRequest indicates an expected call of DisassociateVpcCidrBlockRequest. -func (mr *MockEC2MockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2)(nil).DisassociateVpcCidrBlockRequest), arg0) -} - -// DisassociateVpcCidrBlockWithContext mocks base method. -func (m *MockEC2) DisassociateVpcCidrBlockWithContext(arg0 context.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - 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 *MockEC2MockRecorder) 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((*MockEC2)(nil).DisassociateVpcCidrBlockWithContext), varargs...) -} - -// EnableAddressTransfer mocks base method. -func (m *MockEC2) EnableAddressTransfer(arg0 *ec2.EnableAddressTransferInput) (*ec2.EnableAddressTransferOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableAddressTransfer", arg0) - ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableAddressTransfer indicates an expected call of EnableAddressTransfer. -func (mr *MockEC2MockRecorder) EnableAddressTransfer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransfer", reflect.TypeOf((*MockEC2)(nil).EnableAddressTransfer), arg0) -} - -// EnableAddressTransferRequest mocks base method. -func (m *MockEC2) EnableAddressTransferRequest(arg0 *ec2.EnableAddressTransferInput) (*request.Request, *ec2.EnableAddressTransferOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableAddressTransferRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableAddressTransferOutput) - return ret0, ret1 -} - -// EnableAddressTransferRequest indicates an expected call of EnableAddressTransferRequest. -func (mr *MockEC2MockRecorder) EnableAddressTransferRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAddressTransferRequest", reflect.TypeOf((*MockEC2)(nil).EnableAddressTransferRequest), arg0) -} - -// EnableAddressTransferWithContext mocks base method. -func (m *MockEC2) EnableAddressTransferWithContext(arg0 context.Context, arg1 *ec2.EnableAddressTransferInput, arg2 ...request.Option) (*ec2.EnableAddressTransferOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableAddressTransferWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableAddressTransferOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableAddressTransferWithContext indicates an expected call of EnableAddressTransferWithContext. -func (mr *MockEC2MockRecorder) EnableAddressTransferWithContext(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, "EnableAddressTransferWithContext", reflect.TypeOf((*MockEC2)(nil).EnableAddressTransferWithContext), varargs...) -} - -// EnableAwsNetworkPerformanceMetricSubscription mocks base method. -func (m *MockEC2) EnableAwsNetworkPerformanceMetricSubscription(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscription", arg0) - ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableAwsNetworkPerformanceMetricSubscription indicates an expected call of EnableAwsNetworkPerformanceMetricSubscription. -func (mr *MockEC2MockRecorder) EnableAwsNetworkPerformanceMetricSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscription", reflect.TypeOf((*MockEC2)(nil).EnableAwsNetworkPerformanceMetricSubscription), arg0) -} - -// EnableAwsNetworkPerformanceMetricSubscriptionRequest mocks base method. -func (m *MockEC2) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput) (*request.Request, *ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) - return ret0, ret1 -} - -// EnableAwsNetworkPerformanceMetricSubscriptionRequest indicates an expected call of EnableAwsNetworkPerformanceMetricSubscriptionRequest. -func (mr *MockEC2MockRecorder) EnableAwsNetworkPerformanceMetricSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableAwsNetworkPerformanceMetricSubscriptionRequest", reflect.TypeOf((*MockEC2)(nil).EnableAwsNetworkPerformanceMetricSubscriptionRequest), arg0) -} - -// EnableAwsNetworkPerformanceMetricSubscriptionWithContext mocks base method. -func (m *MockEC2) EnableAwsNetworkPerformanceMetricSubscriptionWithContext(arg0 context.Context, arg1 *ec2.EnableAwsNetworkPerformanceMetricSubscriptionInput, arg2 ...request.Option) (*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableAwsNetworkPerformanceMetricSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableAwsNetworkPerformanceMetricSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableAwsNetworkPerformanceMetricSubscriptionWithContext indicates an expected call of EnableAwsNetworkPerformanceMetricSubscriptionWithContext. -func (mr *MockEC2MockRecorder) EnableAwsNetworkPerformanceMetricSubscriptionWithContext(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, "EnableAwsNetworkPerformanceMetricSubscriptionWithContext", reflect.TypeOf((*MockEC2)(nil).EnableAwsNetworkPerformanceMetricSubscriptionWithContext), varargs...) -} - -// EnableEbsEncryptionByDefault mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2)(nil).EnableEbsEncryptionByDefault), arg0) -} - -// EnableEbsEncryptionByDefaultRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2)(nil).EnableEbsEncryptionByDefaultRequest), arg0) -} - -// EnableEbsEncryptionByDefaultWithContext mocks base method. -func (m *MockEC2) EnableEbsEncryptionByDefaultWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) -} - -// EnableFastLaunch mocks base method. -func (m *MockEC2) EnableFastLaunch(arg0 *ec2.EnableFastLaunchInput) (*ec2.EnableFastLaunchOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableFastLaunch", arg0) - ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableFastLaunch indicates an expected call of EnableFastLaunch. -func (mr *MockEC2MockRecorder) EnableFastLaunch(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunch", reflect.TypeOf((*MockEC2)(nil).EnableFastLaunch), arg0) -} - -// EnableFastLaunchRequest mocks base method. -func (m *MockEC2) EnableFastLaunchRequest(arg0 *ec2.EnableFastLaunchInput) (*request.Request, *ec2.EnableFastLaunchOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableFastLaunchRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableFastLaunchOutput) - return ret0, ret1 -} - -// EnableFastLaunchRequest indicates an expected call of EnableFastLaunchRequest. -func (mr *MockEC2MockRecorder) EnableFastLaunchRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastLaunchRequest", reflect.TypeOf((*MockEC2)(nil).EnableFastLaunchRequest), arg0) -} - -// EnableFastLaunchWithContext mocks base method. -func (m *MockEC2) EnableFastLaunchWithContext(arg0 context.Context, arg1 *ec2.EnableFastLaunchInput, arg2 ...request.Option) (*ec2.EnableFastLaunchOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableFastLaunchWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableFastLaunchOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableFastLaunchWithContext indicates an expected call of EnableFastLaunchWithContext. -func (mr *MockEC2MockRecorder) EnableFastLaunchWithContext(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, "EnableFastLaunchWithContext", reflect.TypeOf((*MockEC2)(nil).EnableFastLaunchWithContext), varargs...) -} - -// EnableFastSnapshotRestores mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2)(nil).EnableFastSnapshotRestores), arg0) -} - -// EnableFastSnapshotRestoresRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2)(nil).EnableFastSnapshotRestoresRequest), arg0) -} - -// EnableFastSnapshotRestoresWithContext mocks base method. -func (m *MockEC2) EnableFastSnapshotRestoresWithContext(arg0 context.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 -} - -// EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext. -func (mr *MockEC2MockRecorder) 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, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2)(nil).EnableFastSnapshotRestoresWithContext), varargs...) -} - -// EnableImage mocks base method. -func (m *MockEC2) EnableImage(arg0 *ec2.EnableImageInput) (*ec2.EnableImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImage", arg0) - ret0, _ := ret[0].(*ec2.EnableImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImage indicates an expected call of EnableImage. -func (mr *MockEC2MockRecorder) EnableImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImage", reflect.TypeOf((*MockEC2)(nil).EnableImage), arg0) -} - -// EnableImageBlockPublicAccess mocks base method. -func (m *MockEC2) EnableImageBlockPublicAccess(arg0 *ec2.EnableImageBlockPublicAccessInput) (*ec2.EnableImageBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImageBlockPublicAccess", arg0) - ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImageBlockPublicAccess indicates an expected call of EnableImageBlockPublicAccess. -func (mr *MockEC2MockRecorder) EnableImageBlockPublicAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccess", reflect.TypeOf((*MockEC2)(nil).EnableImageBlockPublicAccess), arg0) -} - -// EnableImageBlockPublicAccessRequest mocks base method. -func (m *MockEC2) EnableImageBlockPublicAccessRequest(arg0 *ec2.EnableImageBlockPublicAccessInput) (*request.Request, *ec2.EnableImageBlockPublicAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableImageBlockPublicAccessOutput) - return ret0, ret1 -} - -// EnableImageBlockPublicAccessRequest indicates an expected call of EnableImageBlockPublicAccessRequest. -func (mr *MockEC2MockRecorder) EnableImageBlockPublicAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageBlockPublicAccessRequest", reflect.TypeOf((*MockEC2)(nil).EnableImageBlockPublicAccessRequest), arg0) -} - -// EnableImageBlockPublicAccessWithContext mocks base method. -func (m *MockEC2) EnableImageBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableImageBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableImageBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableImageBlockPublicAccessWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableImageBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImageBlockPublicAccessWithContext indicates an expected call of EnableImageBlockPublicAccessWithContext. -func (mr *MockEC2MockRecorder) EnableImageBlockPublicAccessWithContext(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, "EnableImageBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2)(nil).EnableImageBlockPublicAccessWithContext), varargs...) -} - -// EnableImageDeprecation mocks base method. -func (m *MockEC2) EnableImageDeprecation(arg0 *ec2.EnableImageDeprecationInput) (*ec2.EnableImageDeprecationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImageDeprecation", arg0) - ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImageDeprecation indicates an expected call of EnableImageDeprecation. -func (mr *MockEC2MockRecorder) EnableImageDeprecation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecation", reflect.TypeOf((*MockEC2)(nil).EnableImageDeprecation), arg0) -} - -// EnableImageDeprecationRequest mocks base method. -func (m *MockEC2) EnableImageDeprecationRequest(arg0 *ec2.EnableImageDeprecationInput) (*request.Request, *ec2.EnableImageDeprecationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImageDeprecationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableImageDeprecationOutput) - return ret0, ret1 -} - -// EnableImageDeprecationRequest indicates an expected call of EnableImageDeprecationRequest. -func (mr *MockEC2MockRecorder) EnableImageDeprecationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageDeprecationRequest", reflect.TypeOf((*MockEC2)(nil).EnableImageDeprecationRequest), arg0) -} - -// EnableImageDeprecationWithContext mocks base method. -func (m *MockEC2) EnableImageDeprecationWithContext(arg0 context.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, "EnableImageDeprecationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableImageDeprecationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImageDeprecationWithContext indicates an expected call of EnableImageDeprecationWithContext. -func (mr *MockEC2MockRecorder) 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, "EnableImageDeprecationWithContext", reflect.TypeOf((*MockEC2)(nil).EnableImageDeprecationWithContext), varargs...) -} - -// EnableImageRequest mocks base method. -func (m *MockEC2) EnableImageRequest(arg0 *ec2.EnableImageInput) (*request.Request, *ec2.EnableImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableImageOutput) - return ret0, ret1 -} - -// EnableImageRequest indicates an expected call of EnableImageRequest. -func (mr *MockEC2MockRecorder) EnableImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableImageRequest", reflect.TypeOf((*MockEC2)(nil).EnableImageRequest), arg0) -} - -// EnableImageWithContext mocks base method. -func (m *MockEC2) EnableImageWithContext(arg0 context.Context, arg1 *ec2.EnableImageInput, arg2 ...request.Option) (*ec2.EnableImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableImageWithContext indicates an expected call of EnableImageWithContext. -func (mr *MockEC2MockRecorder) EnableImageWithContext(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, "EnableImageWithContext", reflect.TypeOf((*MockEC2)(nil).EnableImageWithContext), varargs...) -} - -// EnableIpamOrganizationAdminAccount mocks base method. -func (m *MockEC2) EnableIpamOrganizationAdminAccount(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccount", arg0) - ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableIpamOrganizationAdminAccount indicates an expected call of EnableIpamOrganizationAdminAccount. -func (mr *MockEC2MockRecorder) EnableIpamOrganizationAdminAccount(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccount", reflect.TypeOf((*MockEC2)(nil).EnableIpamOrganizationAdminAccount), arg0) -} - -// EnableIpamOrganizationAdminAccountRequest mocks base method. -func (m *MockEC2) EnableIpamOrganizationAdminAccountRequest(arg0 *ec2.EnableIpamOrganizationAdminAccountInput) (*request.Request, *ec2.EnableIpamOrganizationAdminAccountOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableIpamOrganizationAdminAccountOutput) - return ret0, ret1 -} - -// EnableIpamOrganizationAdminAccountRequest indicates an expected call of EnableIpamOrganizationAdminAccountRequest. -func (mr *MockEC2MockRecorder) EnableIpamOrganizationAdminAccountRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableIpamOrganizationAdminAccountRequest", reflect.TypeOf((*MockEC2)(nil).EnableIpamOrganizationAdminAccountRequest), arg0) -} - -// EnableIpamOrganizationAdminAccountWithContext mocks base method. -func (m *MockEC2) EnableIpamOrganizationAdminAccountWithContext(arg0 context.Context, arg1 *ec2.EnableIpamOrganizationAdminAccountInput, arg2 ...request.Option) (*ec2.EnableIpamOrganizationAdminAccountOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableIpamOrganizationAdminAccountWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableIpamOrganizationAdminAccountOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableIpamOrganizationAdminAccountWithContext indicates an expected call of EnableIpamOrganizationAdminAccountWithContext. -func (mr *MockEC2MockRecorder) EnableIpamOrganizationAdminAccountWithContext(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, "EnableIpamOrganizationAdminAccountWithContext", reflect.TypeOf((*MockEC2)(nil).EnableIpamOrganizationAdminAccountWithContext), varargs...) -} - -// EnableReachabilityAnalyzerOrganizationSharing mocks base method. -func (m *MockEC2) EnableReachabilityAnalyzerOrganizationSharing(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharing", arg0) - ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableReachabilityAnalyzerOrganizationSharing indicates an expected call of EnableReachabilityAnalyzerOrganizationSharing. -func (mr *MockEC2MockRecorder) EnableReachabilityAnalyzerOrganizationSharing(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharing", reflect.TypeOf((*MockEC2)(nil).EnableReachabilityAnalyzerOrganizationSharing), arg0) -} - -// EnableReachabilityAnalyzerOrganizationSharingRequest mocks base method. -func (m *MockEC2) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput) (*request.Request, *ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) - return ret0, ret1 -} - -// EnableReachabilityAnalyzerOrganizationSharingRequest indicates an expected call of EnableReachabilityAnalyzerOrganizationSharingRequest. -func (mr *MockEC2MockRecorder) EnableReachabilityAnalyzerOrganizationSharingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableReachabilityAnalyzerOrganizationSharingRequest", reflect.TypeOf((*MockEC2)(nil).EnableReachabilityAnalyzerOrganizationSharingRequest), arg0) -} - -// EnableReachabilityAnalyzerOrganizationSharingWithContext mocks base method. -func (m *MockEC2) EnableReachabilityAnalyzerOrganizationSharingWithContext(arg0 context.Context, arg1 *ec2.EnableReachabilityAnalyzerOrganizationSharingInput, arg2 ...request.Option) (*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableReachabilityAnalyzerOrganizationSharingWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableReachabilityAnalyzerOrganizationSharingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableReachabilityAnalyzerOrganizationSharingWithContext indicates an expected call of EnableReachabilityAnalyzerOrganizationSharingWithContext. -func (mr *MockEC2MockRecorder) EnableReachabilityAnalyzerOrganizationSharingWithContext(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, "EnableReachabilityAnalyzerOrganizationSharingWithContext", reflect.TypeOf((*MockEC2)(nil).EnableReachabilityAnalyzerOrganizationSharingWithContext), varargs...) -} - -// EnableSerialConsoleAccess mocks base method. -func (m *MockEC2) EnableSerialConsoleAccess(arg0 *ec2.EnableSerialConsoleAccessInput) (*ec2.EnableSerialConsoleAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableSerialConsoleAccess", arg0) - ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableSerialConsoleAccess indicates an expected call of EnableSerialConsoleAccess. -func (mr *MockEC2MockRecorder) EnableSerialConsoleAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccess", reflect.TypeOf((*MockEC2)(nil).EnableSerialConsoleAccess), arg0) -} - -// EnableSerialConsoleAccessRequest mocks base method. -func (m *MockEC2) EnableSerialConsoleAccessRequest(arg0 *ec2.EnableSerialConsoleAccessInput) (*request.Request, *ec2.EnableSerialConsoleAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableSerialConsoleAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableSerialConsoleAccessOutput) - return ret0, ret1 -} - -// EnableSerialConsoleAccessRequest indicates an expected call of EnableSerialConsoleAccessRequest. -func (mr *MockEC2MockRecorder) EnableSerialConsoleAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSerialConsoleAccessRequest", reflect.TypeOf((*MockEC2)(nil).EnableSerialConsoleAccessRequest), arg0) -} - -// EnableSerialConsoleAccessWithContext mocks base method. -func (m *MockEC2) EnableSerialConsoleAccessWithContext(arg0 context.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, "EnableSerialConsoleAccessWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableSerialConsoleAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableSerialConsoleAccessWithContext indicates an expected call of EnableSerialConsoleAccessWithContext. -func (mr *MockEC2MockRecorder) 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, "EnableSerialConsoleAccessWithContext", reflect.TypeOf((*MockEC2)(nil).EnableSerialConsoleAccessWithContext), varargs...) -} - -// EnableSnapshotBlockPublicAccess mocks base method. -func (m *MockEC2) EnableSnapshotBlockPublicAccess(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccess", arg0) - ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableSnapshotBlockPublicAccess indicates an expected call of EnableSnapshotBlockPublicAccess. -func (mr *MockEC2MockRecorder) EnableSnapshotBlockPublicAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccess", reflect.TypeOf((*MockEC2)(nil).EnableSnapshotBlockPublicAccess), arg0) -} - -// EnableSnapshotBlockPublicAccessRequest mocks base method. -func (m *MockEC2) EnableSnapshotBlockPublicAccessRequest(arg0 *ec2.EnableSnapshotBlockPublicAccessInput) (*request.Request, *ec2.EnableSnapshotBlockPublicAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableSnapshotBlockPublicAccessOutput) - return ret0, ret1 -} - -// EnableSnapshotBlockPublicAccessRequest indicates an expected call of EnableSnapshotBlockPublicAccessRequest. -func (mr *MockEC2MockRecorder) EnableSnapshotBlockPublicAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableSnapshotBlockPublicAccessRequest", reflect.TypeOf((*MockEC2)(nil).EnableSnapshotBlockPublicAccessRequest), arg0) -} - -// EnableSnapshotBlockPublicAccessWithContext mocks base method. -func (m *MockEC2) EnableSnapshotBlockPublicAccessWithContext(arg0 context.Context, arg1 *ec2.EnableSnapshotBlockPublicAccessInput, arg2 ...request.Option) (*ec2.EnableSnapshotBlockPublicAccessOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableSnapshotBlockPublicAccessWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableSnapshotBlockPublicAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableSnapshotBlockPublicAccessWithContext indicates an expected call of EnableSnapshotBlockPublicAccessWithContext. -func (mr *MockEC2MockRecorder) EnableSnapshotBlockPublicAccessWithContext(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, "EnableSnapshotBlockPublicAccessWithContext", reflect.TypeOf((*MockEC2)(nil).EnableSnapshotBlockPublicAccessWithContext), varargs...) -} - -// EnableTransitGatewayRouteTablePropagation mocks base method. -func (m *MockEC2) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagation", arg0) - ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableTransitGatewayRouteTablePropagation indicates an expected call of EnableTransitGatewayRouteTablePropagation. -func (mr *MockEC2MockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2)(nil).EnableTransitGatewayRouteTablePropagation), arg0) -} - -// EnableTransitGatewayRouteTablePropagationRequest mocks base method. -func (m *MockEC2) EnableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) - return ret0, ret1 -} - -// EnableTransitGatewayRouteTablePropagationRequest indicates an expected call of EnableTransitGatewayRouteTablePropagationRequest. -func (mr *MockEC2MockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0) -} - -// EnableTransitGatewayRouteTablePropagationWithContext mocks base method. -func (m *MockEC2) EnableTransitGatewayRouteTablePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableTransitGatewayRouteTablePropagationWithContext indicates an expected call of EnableTransitGatewayRouteTablePropagationWithContext. -func (mr *MockEC2MockRecorder) EnableTransitGatewayRouteTablePropagationWithContext(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, "EnableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2)(nil).EnableTransitGatewayRouteTablePropagationWithContext), varargs...) -} - -// EnableVgwRoutePropagation mocks base method. -func (m *MockEC2) EnableVgwRoutePropagation(arg0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVgwRoutePropagation", arg0) - ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVgwRoutePropagation indicates an expected call of EnableVgwRoutePropagation. -func (mr *MockEC2MockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2)(nil).EnableVgwRoutePropagation), arg0) -} - -// EnableVgwRoutePropagationRequest mocks base method. -func (m *MockEC2) EnableVgwRoutePropagationRequest(arg0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVgwRoutePropagationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableVgwRoutePropagationOutput) - return ret0, ret1 -} - -// EnableVgwRoutePropagationRequest indicates an expected call of EnableVgwRoutePropagationRequest. -func (mr *MockEC2MockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2)(nil).EnableVgwRoutePropagationRequest), arg0) -} - -// EnableVgwRoutePropagationWithContext mocks base method. -func (m *MockEC2) EnableVgwRoutePropagationWithContext(arg0 context.Context, arg1 *ec2.EnableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableVgwRoutePropagationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVgwRoutePropagationWithContext indicates an expected call of EnableVgwRoutePropagationWithContext. -func (mr *MockEC2MockRecorder) EnableVgwRoutePropagationWithContext(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, "EnableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2)(nil).EnableVgwRoutePropagationWithContext), varargs...) -} - -// EnableVolumeIO mocks base method. -func (m *MockEC2) EnableVolumeIO(arg0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVolumeIO", arg0) - ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVolumeIO indicates an expected call of EnableVolumeIO. -func (mr *MockEC2MockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2)(nil).EnableVolumeIO), arg0) -} - -// EnableVolumeIORequest mocks base method. -func (m *MockEC2) EnableVolumeIORequest(arg0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVolumeIORequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableVolumeIOOutput) - return ret0, ret1 -} - -// EnableVolumeIORequest indicates an expected call of EnableVolumeIORequest. -func (mr *MockEC2MockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2)(nil).EnableVolumeIORequest), arg0) -} - -// EnableVolumeIOWithContext mocks base method. -func (m *MockEC2) EnableVolumeIOWithContext(arg0 context.Context, arg1 *ec2.EnableVolumeIOInput, arg2 ...request.Option) (*ec2.EnableVolumeIOOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableVolumeIOWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVolumeIOWithContext indicates an expected call of EnableVolumeIOWithContext. -func (mr *MockEC2MockRecorder) EnableVolumeIOWithContext(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, "EnableVolumeIOWithContext", reflect.TypeOf((*MockEC2)(nil).EnableVolumeIOWithContext), varargs...) -} - -// EnableVpcClassicLink mocks base method. -func (m *MockEC2) EnableVpcClassicLink(arg0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVpcClassicLink", arg0) - ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVpcClassicLink indicates an expected call of EnableVpcClassicLink. -func (mr *MockEC2MockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLink), arg0) -} - -// EnableVpcClassicLinkDnsSupport mocks base method. -func (m *MockEC2) EnableVpcClassicLinkDnsSupport(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupport", arg0) - ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVpcClassicLinkDnsSupport indicates an expected call of EnableVpcClassicLinkDnsSupport. -func (mr *MockEC2MockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLinkDnsSupport), arg0) -} - -// EnableVpcClassicLinkDnsSupportRequest mocks base method. -func (m *MockEC2) EnableVpcClassicLinkDnsSupportRequest(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkDnsSupportOutput) - return ret0, ret1 -} - -// EnableVpcClassicLinkDnsSupportRequest indicates an expected call of EnableVpcClassicLinkDnsSupportRequest. -func (mr *MockEC2MockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0) -} - -// EnableVpcClassicLinkDnsSupportWithContext mocks base method. -func (m *MockEC2) EnableVpcClassicLinkDnsSupportWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVpcClassicLinkDnsSupportWithContext indicates an expected call of EnableVpcClassicLinkDnsSupportWithContext. -func (mr *MockEC2MockRecorder) EnableVpcClassicLinkDnsSupportWithContext(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, "EnableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLinkDnsSupportWithContext), varargs...) -} - -// EnableVpcClassicLinkRequest mocks base method. -func (m *MockEC2) EnableVpcClassicLinkRequest(arg0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableVpcClassicLinkRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkOutput) - return ret0, ret1 -} - -// EnableVpcClassicLinkRequest indicates an expected call of EnableVpcClassicLinkRequest. -func (mr *MockEC2MockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLinkRequest), arg0) -} - -// EnableVpcClassicLinkWithContext mocks base method. -func (m *MockEC2) EnableVpcClassicLinkWithContext(arg0 context.Context, arg1 *ec2.EnableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableVpcClassicLinkWithContext", varargs...) - ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableVpcClassicLinkWithContext indicates an expected call of EnableVpcClassicLinkWithContext. -func (mr *MockEC2MockRecorder) EnableVpcClassicLinkWithContext(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, "EnableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2)(nil).EnableVpcClassicLinkWithContext), varargs...) -} - -// ExportClientVpnClientCertificateRevocationList mocks base method. -func (m *MockEC2) ExportClientVpnClientCertificateRevocationList(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationList", arg0) - ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportClientVpnClientCertificateRevocationList indicates an expected call of ExportClientVpnClientCertificateRevocationList. -func (mr *MockEC2MockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientCertificateRevocationList), arg0) -} - -// ExportClientVpnClientCertificateRevocationListRequest mocks base method. -func (m *MockEC2) ExportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) - return ret0, ret1 -} - -// ExportClientVpnClientCertificateRevocationListRequest indicates an expected call of ExportClientVpnClientCertificateRevocationListRequest. -func (mr *MockEC2MockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0) -} - -// ExportClientVpnClientCertificateRevocationListWithContext mocks base method. -func (m *MockEC2) ExportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ExportClientVpnClientCertificateRevocationListWithContext. -func (mr *MockEC2MockRecorder) ExportClientVpnClientCertificateRevocationListWithContext(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, "ExportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientCertificateRevocationListWithContext), varargs...) -} - -// ExportClientVpnClientConfiguration mocks base method. -func (m *MockEC2) ExportClientVpnClientConfiguration(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportClientVpnClientConfiguration", arg0) - ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportClientVpnClientConfiguration indicates an expected call of ExportClientVpnClientConfiguration. -func (mr *MockEC2MockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientConfiguration), arg0) -} - -// ExportClientVpnClientConfigurationRequest mocks base method. -func (m *MockEC2) ExportClientVpnClientConfigurationRequest(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ExportClientVpnClientConfigurationOutput) - return ret0, ret1 -} - -// ExportClientVpnClientConfigurationRequest indicates an expected call of ExportClientVpnClientConfigurationRequest. -func (mr *MockEC2MockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientConfigurationRequest), arg0) -} - -// ExportClientVpnClientConfigurationWithContext mocks base method. -func (m *MockEC2) ExportClientVpnClientConfigurationWithContext(arg0 context.Context, arg1 *ec2.ExportClientVpnClientConfigurationInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportClientVpnClientConfigurationWithContext indicates an expected call of ExportClientVpnClientConfigurationWithContext. -func (mr *MockEC2MockRecorder) ExportClientVpnClientConfigurationWithContext(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, "ExportClientVpnClientConfigurationWithContext", reflect.TypeOf((*MockEC2)(nil).ExportClientVpnClientConfigurationWithContext), varargs...) -} - -// ExportImage mocks base method. -func (m *MockEC2) ExportImage(arg0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportImage", arg0) - ret0, _ := ret[0].(*ec2.ExportImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportImage indicates an expected call of ExportImage. -func (mr *MockEC2MockRecorder) ExportImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2)(nil).ExportImage), arg0) -} - -// ExportImageRequest mocks base method. -func (m *MockEC2) ExportImageRequest(arg0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ExportImageOutput) - return ret0, ret1 -} - -// ExportImageRequest indicates an expected call of ExportImageRequest. -func (mr *MockEC2MockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2)(nil).ExportImageRequest), arg0) -} - -// ExportImageWithContext mocks base method. -func (m *MockEC2) ExportImageWithContext(arg0 context.Context, arg1 *ec2.ExportImageInput, arg2 ...request.Option) (*ec2.ExportImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ExportImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ExportImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportImageWithContext indicates an expected call of ExportImageWithContext. -func (mr *MockEC2MockRecorder) ExportImageWithContext(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, "ExportImageWithContext", reflect.TypeOf((*MockEC2)(nil).ExportImageWithContext), varargs...) -} - -// ExportTransitGatewayRoutes mocks base method. -func (m *MockEC2) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0) - ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes. -func (mr *MockEC2MockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2)(nil).ExportTransitGatewayRoutes), arg0) -} - -// ExportTransitGatewayRoutesRequest mocks base method. -func (m *MockEC2) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput) - return ret0, ret1 -} - -// ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest. -func (mr *MockEC2MockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2)(nil).ExportTransitGatewayRoutesRequest), arg0) -} - -// ExportTransitGatewayRoutesWithContext mocks base method. -func (m *MockEC2) ExportTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ExportTransitGatewayRoutesWithContext indicates an expected call of ExportTransitGatewayRoutesWithContext. -func (mr *MockEC2MockRecorder) ExportTransitGatewayRoutesWithContext(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, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2)(nil).ExportTransitGatewayRoutesWithContext), varargs...) -} - -// GetAssociatedEnclaveCertificateIamRoles mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetAssociatedEnclaveCertificateIamRoles(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRoles", reflect.TypeOf((*MockEC2)(nil).GetAssociatedEnclaveCertificateIamRoles), arg0) -} - -// GetAssociatedEnclaveCertificateIamRolesRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetAssociatedEnclaveCertificateIamRolesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedEnclaveCertificateIamRolesRequest", reflect.TypeOf((*MockEC2)(nil).GetAssociatedEnclaveCertificateIamRolesRequest), arg0) -} - -// GetAssociatedEnclaveCertificateIamRolesWithContext mocks base method. -func (m *MockEC2) GetAssociatedEnclaveCertificateIamRolesWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).GetAssociatedEnclaveCertificateIamRolesWithContext), varargs...) -} - -// GetAssociatedIpv6PoolCidrs mocks base method. -func (m *MockEC2) GetAssociatedIpv6PoolCidrs(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrs", arg0) - ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAssociatedIpv6PoolCidrs indicates an expected call of GetAssociatedIpv6PoolCidrs. -func (mr *MockEC2MockRecorder) GetAssociatedIpv6PoolCidrs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrs", reflect.TypeOf((*MockEC2)(nil).GetAssociatedIpv6PoolCidrs), arg0) -} - -// GetAssociatedIpv6PoolCidrsPages mocks base method. -func (m *MockEC2) GetAssociatedIpv6PoolCidrsPages(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput, arg1 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetAssociatedIpv6PoolCidrsPages indicates an expected call of GetAssociatedIpv6PoolCidrsPages. -func (mr *MockEC2MockRecorder) GetAssociatedIpv6PoolCidrsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPages", reflect.TypeOf((*MockEC2)(nil).GetAssociatedIpv6PoolCidrsPages), arg0, arg1) -} - -// GetAssociatedIpv6PoolCidrsPagesWithContext mocks base method. -func (m *MockEC2) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 func(*ec2.GetAssociatedIpv6PoolCidrsOutput, 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, "GetAssociatedIpv6PoolCidrsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetAssociatedIpv6PoolCidrsPagesWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsPagesWithContext. -func (mr *MockEC2MockRecorder) GetAssociatedIpv6PoolCidrsPagesWithContext(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, "GetAssociatedIpv6PoolCidrsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetAssociatedIpv6PoolCidrsPagesWithContext), varargs...) -} - -// GetAssociatedIpv6PoolCidrsRequest mocks base method. -func (m *MockEC2) GetAssociatedIpv6PoolCidrsRequest(arg0 *ec2.GetAssociatedIpv6PoolCidrsInput) (*request.Request, *ec2.GetAssociatedIpv6PoolCidrsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetAssociatedIpv6PoolCidrsOutput) - return ret0, ret1 -} - -// GetAssociatedIpv6PoolCidrsRequest indicates an expected call of GetAssociatedIpv6PoolCidrsRequest. -func (mr *MockEC2MockRecorder) GetAssociatedIpv6PoolCidrsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsRequest", reflect.TypeOf((*MockEC2)(nil).GetAssociatedIpv6PoolCidrsRequest), arg0) -} - -// GetAssociatedIpv6PoolCidrsWithContext mocks base method. -func (m *MockEC2) GetAssociatedIpv6PoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetAssociatedIpv6PoolCidrsInput, arg2 ...request.Option) (*ec2.GetAssociatedIpv6PoolCidrsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetAssociatedIpv6PoolCidrsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetAssociatedIpv6PoolCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAssociatedIpv6PoolCidrsWithContext indicates an expected call of GetAssociatedIpv6PoolCidrsWithContext. -func (mr *MockEC2MockRecorder) GetAssociatedIpv6PoolCidrsWithContext(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, "GetAssociatedIpv6PoolCidrsWithContext", reflect.TypeOf((*MockEC2)(nil).GetAssociatedIpv6PoolCidrsWithContext), varargs...) -} - -// GetAwsNetworkPerformanceData mocks base method. -func (m *MockEC2) GetAwsNetworkPerformanceData(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*ec2.GetAwsNetworkPerformanceDataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceData", arg0) - ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAwsNetworkPerformanceData indicates an expected call of GetAwsNetworkPerformanceData. -func (mr *MockEC2MockRecorder) GetAwsNetworkPerformanceData(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceData", reflect.TypeOf((*MockEC2)(nil).GetAwsNetworkPerformanceData), arg0) -} - -// GetAwsNetworkPerformanceDataPages mocks base method. -func (m *MockEC2) GetAwsNetworkPerformanceDataPages(arg0 *ec2.GetAwsNetworkPerformanceDataInput, arg1 func(*ec2.GetAwsNetworkPerformanceDataOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetAwsNetworkPerformanceDataPages indicates an expected call of GetAwsNetworkPerformanceDataPages. -func (mr *MockEC2MockRecorder) GetAwsNetworkPerformanceDataPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataPages", reflect.TypeOf((*MockEC2)(nil).GetAwsNetworkPerformanceDataPages), arg0, arg1) -} - -// GetAwsNetworkPerformanceDataPagesWithContext mocks base method. -func (m *MockEC2) GetAwsNetworkPerformanceDataPagesWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 func(*ec2.GetAwsNetworkPerformanceDataOutput, 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, "GetAwsNetworkPerformanceDataPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetAwsNetworkPerformanceDataPagesWithContext indicates an expected call of GetAwsNetworkPerformanceDataPagesWithContext. -func (mr *MockEC2MockRecorder) GetAwsNetworkPerformanceDataPagesWithContext(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, "GetAwsNetworkPerformanceDataPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetAwsNetworkPerformanceDataPagesWithContext), varargs...) -} - -// GetAwsNetworkPerformanceDataRequest mocks base method. -func (m *MockEC2) GetAwsNetworkPerformanceDataRequest(arg0 *ec2.GetAwsNetworkPerformanceDataInput) (*request.Request, *ec2.GetAwsNetworkPerformanceDataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetAwsNetworkPerformanceDataOutput) - return ret0, ret1 -} - -// GetAwsNetworkPerformanceDataRequest indicates an expected call of GetAwsNetworkPerformanceDataRequest. -func (mr *MockEC2MockRecorder) GetAwsNetworkPerformanceDataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAwsNetworkPerformanceDataRequest", reflect.TypeOf((*MockEC2)(nil).GetAwsNetworkPerformanceDataRequest), arg0) -} - -// GetAwsNetworkPerformanceDataWithContext mocks base method. -func (m *MockEC2) GetAwsNetworkPerformanceDataWithContext(arg0 context.Context, arg1 *ec2.GetAwsNetworkPerformanceDataInput, arg2 ...request.Option) (*ec2.GetAwsNetworkPerformanceDataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetAwsNetworkPerformanceDataWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetAwsNetworkPerformanceDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetAwsNetworkPerformanceDataWithContext indicates an expected call of GetAwsNetworkPerformanceDataWithContext. -func (mr *MockEC2MockRecorder) GetAwsNetworkPerformanceDataWithContext(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, "GetAwsNetworkPerformanceDataWithContext", reflect.TypeOf((*MockEC2)(nil).GetAwsNetworkPerformanceDataWithContext), varargs...) -} - -// GetCapacityReservationUsage mocks base method. -func (m *MockEC2) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0) - ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage. -func (mr *MockEC2MockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2)(nil).GetCapacityReservationUsage), arg0) -} - -// GetCapacityReservationUsageRequest mocks base method. -func (m *MockEC2) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput) - return ret0, ret1 -} - -// GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest. -func (mr *MockEC2MockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2)(nil).GetCapacityReservationUsageRequest), arg0) -} - -// GetCapacityReservationUsageWithContext mocks base method. -func (m *MockEC2) GetCapacityReservationUsageWithContext(arg0 context.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCapacityReservationUsageWithContext indicates an expected call of GetCapacityReservationUsageWithContext. -func (mr *MockEC2MockRecorder) GetCapacityReservationUsageWithContext(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, "GetCapacityReservationUsageWithContext", reflect.TypeOf((*MockEC2)(nil).GetCapacityReservationUsageWithContext), varargs...) -} - -// GetCoipPoolUsage mocks base method. -func (m *MockEC2) GetCoipPoolUsage(arg0 *ec2.GetCoipPoolUsageInput) (*ec2.GetCoipPoolUsageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCoipPoolUsage", arg0) - ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCoipPoolUsage indicates an expected call of GetCoipPoolUsage. -func (mr *MockEC2MockRecorder) GetCoipPoolUsage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsage", reflect.TypeOf((*MockEC2)(nil).GetCoipPoolUsage), arg0) -} - -// GetCoipPoolUsageRequest mocks base method. -func (m *MockEC2) GetCoipPoolUsageRequest(arg0 *ec2.GetCoipPoolUsageInput) (*request.Request, *ec2.GetCoipPoolUsageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCoipPoolUsageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetCoipPoolUsageOutput) - return ret0, ret1 -} - -// GetCoipPoolUsageRequest indicates an expected call of GetCoipPoolUsageRequest. -func (mr *MockEC2MockRecorder) GetCoipPoolUsageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageRequest", reflect.TypeOf((*MockEC2)(nil).GetCoipPoolUsageRequest), arg0) -} - -// GetCoipPoolUsageWithContext mocks base method. -func (m *MockEC2) GetCoipPoolUsageWithContext(arg0 context.Context, arg1 *ec2.GetCoipPoolUsageInput, arg2 ...request.Option) (*ec2.GetCoipPoolUsageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetCoipPoolUsageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetCoipPoolUsageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetCoipPoolUsageWithContext indicates an expected call of GetCoipPoolUsageWithContext. -func (mr *MockEC2MockRecorder) GetCoipPoolUsageWithContext(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, "GetCoipPoolUsageWithContext", reflect.TypeOf((*MockEC2)(nil).GetCoipPoolUsageWithContext), varargs...) -} - -// GetConsoleOutput mocks base method. -func (m *MockEC2) GetConsoleOutput(arg0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConsoleOutput", arg0) - ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConsoleOutput indicates an expected call of GetConsoleOutput. -func (mr *MockEC2MockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2)(nil).GetConsoleOutput), arg0) -} - -// GetConsoleOutputRequest mocks base method. -func (m *MockEC2) GetConsoleOutputRequest(arg0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConsoleOutputRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetConsoleOutputOutput) - return ret0, ret1 -} - -// GetConsoleOutputRequest indicates an expected call of GetConsoleOutputRequest. -func (mr *MockEC2MockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2)(nil).GetConsoleOutputRequest), arg0) -} - -// GetConsoleOutputWithContext mocks base method. -func (m *MockEC2) GetConsoleOutputWithContext(arg0 context.Context, arg1 *ec2.GetConsoleOutputInput, arg2 ...request.Option) (*ec2.GetConsoleOutputOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetConsoleOutputWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConsoleOutputWithContext indicates an expected call of GetConsoleOutputWithContext. -func (mr *MockEC2MockRecorder) GetConsoleOutputWithContext(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, "GetConsoleOutputWithContext", reflect.TypeOf((*MockEC2)(nil).GetConsoleOutputWithContext), varargs...) -} - -// GetConsoleScreenshot mocks base method. -func (m *MockEC2) GetConsoleScreenshot(arg0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConsoleScreenshot", arg0) - ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConsoleScreenshot indicates an expected call of GetConsoleScreenshot. -func (mr *MockEC2MockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2)(nil).GetConsoleScreenshot), arg0) -} - -// GetConsoleScreenshotRequest mocks base method. -func (m *MockEC2) GetConsoleScreenshotRequest(arg0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetConsoleScreenshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetConsoleScreenshotOutput) - return ret0, ret1 -} - -// GetConsoleScreenshotRequest indicates an expected call of GetConsoleScreenshotRequest. -func (mr *MockEC2MockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2)(nil).GetConsoleScreenshotRequest), arg0) -} - -// GetConsoleScreenshotWithContext mocks base method. -func (m *MockEC2) GetConsoleScreenshotWithContext(arg0 context.Context, arg1 *ec2.GetConsoleScreenshotInput, arg2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetConsoleScreenshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetConsoleScreenshotWithContext indicates an expected call of GetConsoleScreenshotWithContext. -func (mr *MockEC2MockRecorder) GetConsoleScreenshotWithContext(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, "GetConsoleScreenshotWithContext", reflect.TypeOf((*MockEC2)(nil).GetConsoleScreenshotWithContext), varargs...) -} - -// GetDefaultCreditSpecification mocks base method. -func (m *MockEC2) GetDefaultCreditSpecification(arg0 *ec2.GetDefaultCreditSpecificationInput) (*ec2.GetDefaultCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDefaultCreditSpecification", arg0) - ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDefaultCreditSpecification indicates an expected call of GetDefaultCreditSpecification. -func (mr *MockEC2MockRecorder) GetDefaultCreditSpecification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecification", reflect.TypeOf((*MockEC2)(nil).GetDefaultCreditSpecification), arg0) -} - -// GetDefaultCreditSpecificationRequest mocks base method. -func (m *MockEC2) GetDefaultCreditSpecificationRequest(arg0 *ec2.GetDefaultCreditSpecificationInput) (*request.Request, *ec2.GetDefaultCreditSpecificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetDefaultCreditSpecificationOutput) - return ret0, ret1 -} - -// GetDefaultCreditSpecificationRequest indicates an expected call of GetDefaultCreditSpecificationRequest. -func (mr *MockEC2MockRecorder) GetDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2)(nil).GetDefaultCreditSpecificationRequest), arg0) -} - -// GetDefaultCreditSpecificationWithContext mocks base method. -func (m *MockEC2) GetDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.GetDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.GetDefaultCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetDefaultCreditSpecificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetDefaultCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetDefaultCreditSpecificationWithContext indicates an expected call of GetDefaultCreditSpecificationWithContext. -func (mr *MockEC2MockRecorder) GetDefaultCreditSpecificationWithContext(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, "GetDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2)(nil).GetDefaultCreditSpecificationWithContext), varargs...) -} - -// GetEbsDefaultKmsKeyId mocks base method. -func (m *MockEC2) GetEbsDefaultKmsKeyId(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyId", arg0) - ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetEbsDefaultKmsKeyId indicates an expected call of GetEbsDefaultKmsKeyId. -func (mr *MockEC2MockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2)(nil).GetEbsDefaultKmsKeyId), arg0) -} - -// GetEbsDefaultKmsKeyIdRequest mocks base method. -func (m *MockEC2) GetEbsDefaultKmsKeyIdRequest(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetEbsDefaultKmsKeyIdOutput) - return ret0, ret1 -} - -// GetEbsDefaultKmsKeyIdRequest indicates an expected call of GetEbsDefaultKmsKeyIdRequest. -func (mr *MockEC2MockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2)(nil).GetEbsDefaultKmsKeyIdRequest), arg0) -} - -// GetEbsDefaultKmsKeyIdWithContext mocks base method. -func (m *MockEC2) GetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.GetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetEbsDefaultKmsKeyIdWithContext indicates an expected call of GetEbsDefaultKmsKeyIdWithContext. -func (mr *MockEC2MockRecorder) GetEbsDefaultKmsKeyIdWithContext(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, "GetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2)(nil).GetEbsDefaultKmsKeyIdWithContext), varargs...) -} - -// GetEbsEncryptionByDefault mocks base method. -func (m *MockEC2) GetEbsEncryptionByDefault(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEbsEncryptionByDefault", arg0) - ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetEbsEncryptionByDefault indicates an expected call of GetEbsEncryptionByDefault. -func (mr *MockEC2MockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2)(nil).GetEbsEncryptionByDefault), arg0) -} - -// GetEbsEncryptionByDefaultRequest mocks base method. -func (m *MockEC2) GetEbsEncryptionByDefaultRequest(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetEbsEncryptionByDefaultOutput) - return ret0, ret1 -} - -// GetEbsEncryptionByDefaultRequest indicates an expected call of GetEbsEncryptionByDefaultRequest. -func (mr *MockEC2MockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2)(nil).GetEbsEncryptionByDefaultRequest), arg0) -} - -// GetEbsEncryptionByDefaultWithContext mocks base method. -func (m *MockEC2) GetEbsEncryptionByDefaultWithContext(arg0 context.Context, arg1 *ec2.GetEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetEbsEncryptionByDefaultWithContext indicates an expected call of GetEbsEncryptionByDefaultWithContext. -func (mr *MockEC2MockRecorder) GetEbsEncryptionByDefaultWithContext(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, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2)(nil).GetEbsEncryptionByDefaultWithContext), varargs...) -} - -// GetFlowLogsIntegrationTemplate mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetFlowLogsIntegrationTemplate(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplate", reflect.TypeOf((*MockEC2)(nil).GetFlowLogsIntegrationTemplate), arg0) -} - -// GetFlowLogsIntegrationTemplateRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetFlowLogsIntegrationTemplateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowLogsIntegrationTemplateRequest", reflect.TypeOf((*MockEC2)(nil).GetFlowLogsIntegrationTemplateRequest), arg0) -} - -// GetFlowLogsIntegrationTemplateWithContext mocks base method. -func (m *MockEC2) GetFlowLogsIntegrationTemplateWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).GetFlowLogsIntegrationTemplateWithContext), varargs...) -} - -// GetGroupsForCapacityReservation mocks base method. -func (m *MockEC2) GetGroupsForCapacityReservation(arg0 *ec2.GetGroupsForCapacityReservationInput) (*ec2.GetGroupsForCapacityReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGroupsForCapacityReservation", arg0) - ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetGroupsForCapacityReservation indicates an expected call of GetGroupsForCapacityReservation. -func (mr *MockEC2MockRecorder) GetGroupsForCapacityReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservation", reflect.TypeOf((*MockEC2)(nil).GetGroupsForCapacityReservation), arg0) -} - -// GetGroupsForCapacityReservationPages mocks base method. -func (m *MockEC2) GetGroupsForCapacityReservationPages(arg0 *ec2.GetGroupsForCapacityReservationInput, arg1 func(*ec2.GetGroupsForCapacityReservationOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetGroupsForCapacityReservationPages indicates an expected call of GetGroupsForCapacityReservationPages. -func (mr *MockEC2MockRecorder) GetGroupsForCapacityReservationPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationPages", reflect.TypeOf((*MockEC2)(nil).GetGroupsForCapacityReservationPages), arg0, arg1) -} - -// GetGroupsForCapacityReservationPagesWithContext mocks base method. -func (m *MockEC2) GetGroupsForCapacityReservationPagesWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 func(*ec2.GetGroupsForCapacityReservationOutput, 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, "GetGroupsForCapacityReservationPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetGroupsForCapacityReservationPagesWithContext indicates an expected call of GetGroupsForCapacityReservationPagesWithContext. -func (mr *MockEC2MockRecorder) GetGroupsForCapacityReservationPagesWithContext(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, "GetGroupsForCapacityReservationPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetGroupsForCapacityReservationPagesWithContext), varargs...) -} - -// GetGroupsForCapacityReservationRequest mocks base method. -func (m *MockEC2) GetGroupsForCapacityReservationRequest(arg0 *ec2.GetGroupsForCapacityReservationInput) (*request.Request, *ec2.GetGroupsForCapacityReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetGroupsForCapacityReservationOutput) - return ret0, ret1 -} - -// GetGroupsForCapacityReservationRequest indicates an expected call of GetGroupsForCapacityReservationRequest. -func (mr *MockEC2MockRecorder) GetGroupsForCapacityReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupsForCapacityReservationRequest", reflect.TypeOf((*MockEC2)(nil).GetGroupsForCapacityReservationRequest), arg0) -} - -// GetGroupsForCapacityReservationWithContext mocks base method. -func (m *MockEC2) GetGroupsForCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.GetGroupsForCapacityReservationInput, arg2 ...request.Option) (*ec2.GetGroupsForCapacityReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetGroupsForCapacityReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetGroupsForCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetGroupsForCapacityReservationWithContext indicates an expected call of GetGroupsForCapacityReservationWithContext. -func (mr *MockEC2MockRecorder) GetGroupsForCapacityReservationWithContext(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, "GetGroupsForCapacityReservationWithContext", reflect.TypeOf((*MockEC2)(nil).GetGroupsForCapacityReservationWithContext), varargs...) -} - -// GetHostReservationPurchasePreview mocks base method. -func (m *MockEC2) GetHostReservationPurchasePreview(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetHostReservationPurchasePreview", arg0) - ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetHostReservationPurchasePreview indicates an expected call of GetHostReservationPurchasePreview. -func (mr *MockEC2MockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2)(nil).GetHostReservationPurchasePreview), arg0) -} - -// GetHostReservationPurchasePreviewRequest mocks base method. -func (m *MockEC2) GetHostReservationPurchasePreviewRequest(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetHostReservationPurchasePreviewOutput) - return ret0, ret1 -} - -// GetHostReservationPurchasePreviewRequest indicates an expected call of GetHostReservationPurchasePreviewRequest. -func (mr *MockEC2MockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2)(nil).GetHostReservationPurchasePreviewRequest), arg0) -} - -// GetHostReservationPurchasePreviewWithContext mocks base method. -func (m *MockEC2) GetHostReservationPurchasePreviewWithContext(arg0 context.Context, arg1 *ec2.GetHostReservationPurchasePreviewInput, arg2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetHostReservationPurchasePreviewWithContext indicates an expected call of GetHostReservationPurchasePreviewWithContext. -func (mr *MockEC2MockRecorder) GetHostReservationPurchasePreviewWithContext(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, "GetHostReservationPurchasePreviewWithContext", reflect.TypeOf((*MockEC2)(nil).GetHostReservationPurchasePreviewWithContext), varargs...) -} - -// GetImageBlockPublicAccessState mocks base method. -func (m *MockEC2) GetImageBlockPublicAccessState(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*ec2.GetImageBlockPublicAccessStateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetImageBlockPublicAccessState", arg0) - ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetImageBlockPublicAccessState indicates an expected call of GetImageBlockPublicAccessState. -func (mr *MockEC2MockRecorder) GetImageBlockPublicAccessState(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessState", reflect.TypeOf((*MockEC2)(nil).GetImageBlockPublicAccessState), arg0) -} - -// GetImageBlockPublicAccessStateRequest mocks base method. -func (m *MockEC2) GetImageBlockPublicAccessStateRequest(arg0 *ec2.GetImageBlockPublicAccessStateInput) (*request.Request, *ec2.GetImageBlockPublicAccessStateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetImageBlockPublicAccessStateOutput) - return ret0, ret1 -} - -// GetImageBlockPublicAccessStateRequest indicates an expected call of GetImageBlockPublicAccessStateRequest. -func (mr *MockEC2MockRecorder) GetImageBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2)(nil).GetImageBlockPublicAccessStateRequest), arg0) -} - -// GetImageBlockPublicAccessStateWithContext mocks base method. -func (m *MockEC2) GetImageBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetImageBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetImageBlockPublicAccessStateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetImageBlockPublicAccessStateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetImageBlockPublicAccessStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetImageBlockPublicAccessStateWithContext indicates an expected call of GetImageBlockPublicAccessStateWithContext. -func (mr *MockEC2MockRecorder) GetImageBlockPublicAccessStateWithContext(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, "GetImageBlockPublicAccessStateWithContext", reflect.TypeOf((*MockEC2)(nil).GetImageBlockPublicAccessStateWithContext), varargs...) -} - -// GetInstanceTypesFromInstanceRequirements mocks base method. -func (m *MockEC2) GetInstanceTypesFromInstanceRequirements(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirements", arg0) - ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInstanceTypesFromInstanceRequirements indicates an expected call of GetInstanceTypesFromInstanceRequirements. -func (mr *MockEC2MockRecorder) GetInstanceTypesFromInstanceRequirements(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirements", reflect.TypeOf((*MockEC2)(nil).GetInstanceTypesFromInstanceRequirements), arg0) -} - -// GetInstanceTypesFromInstanceRequirementsPages mocks base method. -func (m *MockEC2) GetInstanceTypesFromInstanceRequirementsPages(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg1 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInstanceTypesFromInstanceRequirementsPages indicates an expected call of GetInstanceTypesFromInstanceRequirementsPages. -func (mr *MockEC2MockRecorder) GetInstanceTypesFromInstanceRequirementsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsPages", reflect.TypeOf((*MockEC2)(nil).GetInstanceTypesFromInstanceRequirementsPages), arg0, arg1) -} - -// GetInstanceTypesFromInstanceRequirementsPagesWithContext mocks base method. -func (m *MockEC2) GetInstanceTypesFromInstanceRequirementsPagesWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 func(*ec2.GetInstanceTypesFromInstanceRequirementsOutput, 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, "GetInstanceTypesFromInstanceRequirementsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetInstanceTypesFromInstanceRequirementsPagesWithContext indicates an expected call of GetInstanceTypesFromInstanceRequirementsPagesWithContext. -func (mr *MockEC2MockRecorder) GetInstanceTypesFromInstanceRequirementsPagesWithContext(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, "GetInstanceTypesFromInstanceRequirementsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetInstanceTypesFromInstanceRequirementsPagesWithContext), varargs...) -} - -// GetInstanceTypesFromInstanceRequirementsRequest mocks base method. -func (m *MockEC2) GetInstanceTypesFromInstanceRequirementsRequest(arg0 *ec2.GetInstanceTypesFromInstanceRequirementsInput) (*request.Request, *ec2.GetInstanceTypesFromInstanceRequirementsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput) - return ret0, ret1 -} - -// GetInstanceTypesFromInstanceRequirementsRequest indicates an expected call of GetInstanceTypesFromInstanceRequirementsRequest. -func (mr *MockEC2MockRecorder) GetInstanceTypesFromInstanceRequirementsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceTypesFromInstanceRequirementsRequest", reflect.TypeOf((*MockEC2)(nil).GetInstanceTypesFromInstanceRequirementsRequest), arg0) -} - -// GetInstanceTypesFromInstanceRequirementsWithContext mocks base method. -func (m *MockEC2) GetInstanceTypesFromInstanceRequirementsWithContext(arg0 context.Context, arg1 *ec2.GetInstanceTypesFromInstanceRequirementsInput, arg2 ...request.Option) (*ec2.GetInstanceTypesFromInstanceRequirementsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInstanceTypesFromInstanceRequirementsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetInstanceTypesFromInstanceRequirementsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInstanceTypesFromInstanceRequirementsWithContext indicates an expected call of GetInstanceTypesFromInstanceRequirementsWithContext. -func (mr *MockEC2MockRecorder) GetInstanceTypesFromInstanceRequirementsWithContext(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, "GetInstanceTypesFromInstanceRequirementsWithContext", reflect.TypeOf((*MockEC2)(nil).GetInstanceTypesFromInstanceRequirementsWithContext), varargs...) -} - -// GetInstanceUefiData mocks base method. -func (m *MockEC2) GetInstanceUefiData(arg0 *ec2.GetInstanceUefiDataInput) (*ec2.GetInstanceUefiDataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceUefiData", arg0) - ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInstanceUefiData indicates an expected call of GetInstanceUefiData. -func (mr *MockEC2MockRecorder) GetInstanceUefiData(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiData", reflect.TypeOf((*MockEC2)(nil).GetInstanceUefiData), arg0) -} - -// GetInstanceUefiDataRequest mocks base method. -func (m *MockEC2) GetInstanceUefiDataRequest(arg0 *ec2.GetInstanceUefiDataInput) (*request.Request, *ec2.GetInstanceUefiDataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetInstanceUefiDataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetInstanceUefiDataOutput) - return ret0, ret1 -} - -// GetInstanceUefiDataRequest indicates an expected call of GetInstanceUefiDataRequest. -func (mr *MockEC2MockRecorder) GetInstanceUefiDataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInstanceUefiDataRequest", reflect.TypeOf((*MockEC2)(nil).GetInstanceUefiDataRequest), arg0) -} - -// GetInstanceUefiDataWithContext mocks base method. -func (m *MockEC2) GetInstanceUefiDataWithContext(arg0 context.Context, arg1 *ec2.GetInstanceUefiDataInput, arg2 ...request.Option) (*ec2.GetInstanceUefiDataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetInstanceUefiDataWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetInstanceUefiDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetInstanceUefiDataWithContext indicates an expected call of GetInstanceUefiDataWithContext. -func (mr *MockEC2MockRecorder) GetInstanceUefiDataWithContext(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, "GetInstanceUefiDataWithContext", reflect.TypeOf((*MockEC2)(nil).GetInstanceUefiDataWithContext), varargs...) -} - -// GetIpamAddressHistory mocks base method. -func (m *MockEC2) GetIpamAddressHistory(arg0 *ec2.GetIpamAddressHistoryInput) (*ec2.GetIpamAddressHistoryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamAddressHistory", arg0) - ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamAddressHistory indicates an expected call of GetIpamAddressHistory. -func (mr *MockEC2MockRecorder) GetIpamAddressHistory(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistory", reflect.TypeOf((*MockEC2)(nil).GetIpamAddressHistory), arg0) -} - -// GetIpamAddressHistoryPages mocks base method. -func (m *MockEC2) GetIpamAddressHistoryPages(arg0 *ec2.GetIpamAddressHistoryInput, arg1 func(*ec2.GetIpamAddressHistoryOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamAddressHistoryPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamAddressHistoryPages indicates an expected call of GetIpamAddressHistoryPages. -func (mr *MockEC2MockRecorder) GetIpamAddressHistoryPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryPages", reflect.TypeOf((*MockEC2)(nil).GetIpamAddressHistoryPages), arg0, arg1) -} - -// GetIpamAddressHistoryPagesWithContext mocks base method. -func (m *MockEC2) GetIpamAddressHistoryPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 func(*ec2.GetIpamAddressHistoryOutput, 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, "GetIpamAddressHistoryPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamAddressHistoryPagesWithContext indicates an expected call of GetIpamAddressHistoryPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamAddressHistoryPagesWithContext(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, "GetIpamAddressHistoryPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamAddressHistoryPagesWithContext), varargs...) -} - -// GetIpamAddressHistoryRequest mocks base method. -func (m *MockEC2) GetIpamAddressHistoryRequest(arg0 *ec2.GetIpamAddressHistoryInput) (*request.Request, *ec2.GetIpamAddressHistoryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamAddressHistoryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamAddressHistoryOutput) - return ret0, ret1 -} - -// GetIpamAddressHistoryRequest indicates an expected call of GetIpamAddressHistoryRequest. -func (mr *MockEC2MockRecorder) GetIpamAddressHistoryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamAddressHistoryRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamAddressHistoryRequest), arg0) -} - -// GetIpamAddressHistoryWithContext mocks base method. -func (m *MockEC2) GetIpamAddressHistoryWithContext(arg0 context.Context, arg1 *ec2.GetIpamAddressHistoryInput, arg2 ...request.Option) (*ec2.GetIpamAddressHistoryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamAddressHistoryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamAddressHistoryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamAddressHistoryWithContext indicates an expected call of GetIpamAddressHistoryWithContext. -func (mr *MockEC2MockRecorder) GetIpamAddressHistoryWithContext(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, "GetIpamAddressHistoryWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamAddressHistoryWithContext), varargs...) -} - -// GetIpamDiscoveredAccounts mocks base method. -func (m *MockEC2) GetIpamDiscoveredAccounts(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*ec2.GetIpamDiscoveredAccountsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredAccounts", arg0) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredAccounts indicates an expected call of GetIpamDiscoveredAccounts. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredAccounts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccounts", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredAccounts), arg0) -} - -// GetIpamDiscoveredAccountsPages mocks base method. -func (m *MockEC2) GetIpamDiscoveredAccountsPages(arg0 *ec2.GetIpamDiscoveredAccountsInput, arg1 func(*ec2.GetIpamDiscoveredAccountsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamDiscoveredAccountsPages indicates an expected call of GetIpamDiscoveredAccountsPages. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredAccountsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsPages", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredAccountsPages), arg0, arg1) -} - -// GetIpamDiscoveredAccountsPagesWithContext mocks base method. -func (m *MockEC2) GetIpamDiscoveredAccountsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 func(*ec2.GetIpamDiscoveredAccountsOutput, 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, "GetIpamDiscoveredAccountsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamDiscoveredAccountsPagesWithContext indicates an expected call of GetIpamDiscoveredAccountsPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredAccountsPagesWithContext(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, "GetIpamDiscoveredAccountsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredAccountsPagesWithContext), varargs...) -} - -// GetIpamDiscoveredAccountsRequest mocks base method. -func (m *MockEC2) GetIpamDiscoveredAccountsRequest(arg0 *ec2.GetIpamDiscoveredAccountsInput) (*request.Request, *ec2.GetIpamDiscoveredAccountsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamDiscoveredAccountsOutput) - return ret0, ret1 -} - -// GetIpamDiscoveredAccountsRequest indicates an expected call of GetIpamDiscoveredAccountsRequest. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredAccountsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredAccountsRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredAccountsRequest), arg0) -} - -// GetIpamDiscoveredAccountsWithContext mocks base method. -func (m *MockEC2) GetIpamDiscoveredAccountsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredAccountsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredAccountsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamDiscoveredAccountsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredAccountsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredAccountsWithContext indicates an expected call of GetIpamDiscoveredAccountsWithContext. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredAccountsWithContext(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, "GetIpamDiscoveredAccountsWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredAccountsWithContext), varargs...) -} - -// GetIpamDiscoveredPublicAddresses mocks base method. -func (m *MockEC2) GetIpamDiscoveredPublicAddresses(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddresses", arg0) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredPublicAddresses indicates an expected call of GetIpamDiscoveredPublicAddresses. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredPublicAddresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddresses", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredPublicAddresses), arg0) -} - -// GetIpamDiscoveredPublicAddressesRequest mocks base method. -func (m *MockEC2) GetIpamDiscoveredPublicAddressesRequest(arg0 *ec2.GetIpamDiscoveredPublicAddressesInput) (*request.Request, *ec2.GetIpamDiscoveredPublicAddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamDiscoveredPublicAddressesOutput) - return ret0, ret1 -} - -// GetIpamDiscoveredPublicAddressesRequest indicates an expected call of GetIpamDiscoveredPublicAddressesRequest. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredPublicAddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredPublicAddressesRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredPublicAddressesRequest), arg0) -} - -// GetIpamDiscoveredPublicAddressesWithContext mocks base method. -func (m *MockEC2) GetIpamDiscoveredPublicAddressesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredPublicAddressesInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredPublicAddressesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamDiscoveredPublicAddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredPublicAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredPublicAddressesWithContext indicates an expected call of GetIpamDiscoveredPublicAddressesWithContext. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredPublicAddressesWithContext(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, "GetIpamDiscoveredPublicAddressesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredPublicAddressesWithContext), varargs...) -} - -// GetIpamDiscoveredResourceCidrs mocks base method. -func (m *MockEC2) GetIpamDiscoveredResourceCidrs(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrs", arg0) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredResourceCidrs indicates an expected call of GetIpamDiscoveredResourceCidrs. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredResourceCidrs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrs", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredResourceCidrs), arg0) -} - -// GetIpamDiscoveredResourceCidrsPages mocks base method. -func (m *MockEC2) GetIpamDiscoveredResourceCidrsPages(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput, arg1 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamDiscoveredResourceCidrsPages indicates an expected call of GetIpamDiscoveredResourceCidrsPages. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsPages", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredResourceCidrsPages), arg0, arg1) -} - -// GetIpamDiscoveredResourceCidrsPagesWithContext mocks base method. -func (m *MockEC2) GetIpamDiscoveredResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 func(*ec2.GetIpamDiscoveredResourceCidrsOutput, 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, "GetIpamDiscoveredResourceCidrsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamDiscoveredResourceCidrsPagesWithContext indicates an expected call of GetIpamDiscoveredResourceCidrsPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredResourceCidrsPagesWithContext(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, "GetIpamDiscoveredResourceCidrsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredResourceCidrsPagesWithContext), varargs...) -} - -// GetIpamDiscoveredResourceCidrsRequest mocks base method. -func (m *MockEC2) GetIpamDiscoveredResourceCidrsRequest(arg0 *ec2.GetIpamDiscoveredResourceCidrsInput) (*request.Request, *ec2.GetIpamDiscoveredResourceCidrsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamDiscoveredResourceCidrsOutput) - return ret0, ret1 -} - -// GetIpamDiscoveredResourceCidrsRequest indicates an expected call of GetIpamDiscoveredResourceCidrsRequest. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredResourceCidrsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamDiscoveredResourceCidrsRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredResourceCidrsRequest), arg0) -} - -// GetIpamDiscoveredResourceCidrsWithContext mocks base method. -func (m *MockEC2) GetIpamDiscoveredResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamDiscoveredResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamDiscoveredResourceCidrsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamDiscoveredResourceCidrsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamDiscoveredResourceCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamDiscoveredResourceCidrsWithContext indicates an expected call of GetIpamDiscoveredResourceCidrsWithContext. -func (mr *MockEC2MockRecorder) GetIpamDiscoveredResourceCidrsWithContext(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, "GetIpamDiscoveredResourceCidrsWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamDiscoveredResourceCidrsWithContext), varargs...) -} - -// GetIpamPoolAllocations mocks base method. -func (m *MockEC2) GetIpamPoolAllocations(arg0 *ec2.GetIpamPoolAllocationsInput) (*ec2.GetIpamPoolAllocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolAllocations", arg0) - ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamPoolAllocations indicates an expected call of GetIpamPoolAllocations. -func (mr *MockEC2MockRecorder) GetIpamPoolAllocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocations", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolAllocations), arg0) -} - -// GetIpamPoolAllocationsPages mocks base method. -func (m *MockEC2) GetIpamPoolAllocationsPages(arg0 *ec2.GetIpamPoolAllocationsInput, arg1 func(*ec2.GetIpamPoolAllocationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolAllocationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamPoolAllocationsPages indicates an expected call of GetIpamPoolAllocationsPages. -func (mr *MockEC2MockRecorder) GetIpamPoolAllocationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsPages", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolAllocationsPages), arg0, arg1) -} - -// GetIpamPoolAllocationsPagesWithContext mocks base method. -func (m *MockEC2) GetIpamPoolAllocationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 func(*ec2.GetIpamPoolAllocationsOutput, 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, "GetIpamPoolAllocationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamPoolAllocationsPagesWithContext indicates an expected call of GetIpamPoolAllocationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamPoolAllocationsPagesWithContext(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, "GetIpamPoolAllocationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolAllocationsPagesWithContext), varargs...) -} - -// GetIpamPoolAllocationsRequest mocks base method. -func (m *MockEC2) GetIpamPoolAllocationsRequest(arg0 *ec2.GetIpamPoolAllocationsInput) (*request.Request, *ec2.GetIpamPoolAllocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolAllocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamPoolAllocationsOutput) - return ret0, ret1 -} - -// GetIpamPoolAllocationsRequest indicates an expected call of GetIpamPoolAllocationsRequest. -func (mr *MockEC2MockRecorder) GetIpamPoolAllocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolAllocationsRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolAllocationsRequest), arg0) -} - -// GetIpamPoolAllocationsWithContext mocks base method. -func (m *MockEC2) GetIpamPoolAllocationsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolAllocationsInput, arg2 ...request.Option) (*ec2.GetIpamPoolAllocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamPoolAllocationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamPoolAllocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamPoolAllocationsWithContext indicates an expected call of GetIpamPoolAllocationsWithContext. -func (mr *MockEC2MockRecorder) GetIpamPoolAllocationsWithContext(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, "GetIpamPoolAllocationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolAllocationsWithContext), varargs...) -} - -// GetIpamPoolCidrs mocks base method. -func (m *MockEC2) GetIpamPoolCidrs(arg0 *ec2.GetIpamPoolCidrsInput) (*ec2.GetIpamPoolCidrsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolCidrs", arg0) - ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamPoolCidrs indicates an expected call of GetIpamPoolCidrs. -func (mr *MockEC2MockRecorder) GetIpamPoolCidrs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrs", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolCidrs), arg0) -} - -// GetIpamPoolCidrsPages mocks base method. -func (m *MockEC2) GetIpamPoolCidrsPages(arg0 *ec2.GetIpamPoolCidrsInput, arg1 func(*ec2.GetIpamPoolCidrsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolCidrsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamPoolCidrsPages indicates an expected call of GetIpamPoolCidrsPages. -func (mr *MockEC2MockRecorder) GetIpamPoolCidrsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsPages", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolCidrsPages), arg0, arg1) -} - -// GetIpamPoolCidrsPagesWithContext mocks base method. -func (m *MockEC2) GetIpamPoolCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 func(*ec2.GetIpamPoolCidrsOutput, 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, "GetIpamPoolCidrsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamPoolCidrsPagesWithContext indicates an expected call of GetIpamPoolCidrsPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamPoolCidrsPagesWithContext(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, "GetIpamPoolCidrsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolCidrsPagesWithContext), varargs...) -} - -// GetIpamPoolCidrsRequest mocks base method. -func (m *MockEC2) GetIpamPoolCidrsRequest(arg0 *ec2.GetIpamPoolCidrsInput) (*request.Request, *ec2.GetIpamPoolCidrsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamPoolCidrsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamPoolCidrsOutput) - return ret0, ret1 -} - -// GetIpamPoolCidrsRequest indicates an expected call of GetIpamPoolCidrsRequest. -func (mr *MockEC2MockRecorder) GetIpamPoolCidrsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamPoolCidrsRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolCidrsRequest), arg0) -} - -// GetIpamPoolCidrsWithContext mocks base method. -func (m *MockEC2) GetIpamPoolCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamPoolCidrsInput, arg2 ...request.Option) (*ec2.GetIpamPoolCidrsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamPoolCidrsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamPoolCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamPoolCidrsWithContext indicates an expected call of GetIpamPoolCidrsWithContext. -func (mr *MockEC2MockRecorder) GetIpamPoolCidrsWithContext(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, "GetIpamPoolCidrsWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamPoolCidrsWithContext), varargs...) -} - -// GetIpamResourceCidrs mocks base method. -func (m *MockEC2) GetIpamResourceCidrs(arg0 *ec2.GetIpamResourceCidrsInput) (*ec2.GetIpamResourceCidrsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamResourceCidrs", arg0) - ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamResourceCidrs indicates an expected call of GetIpamResourceCidrs. -func (mr *MockEC2MockRecorder) GetIpamResourceCidrs(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrs", reflect.TypeOf((*MockEC2)(nil).GetIpamResourceCidrs), arg0) -} - -// GetIpamResourceCidrsPages mocks base method. -func (m *MockEC2) GetIpamResourceCidrsPages(arg0 *ec2.GetIpamResourceCidrsInput, arg1 func(*ec2.GetIpamResourceCidrsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamResourceCidrsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamResourceCidrsPages indicates an expected call of GetIpamResourceCidrsPages. -func (mr *MockEC2MockRecorder) GetIpamResourceCidrsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsPages", reflect.TypeOf((*MockEC2)(nil).GetIpamResourceCidrsPages), arg0, arg1) -} - -// GetIpamResourceCidrsPagesWithContext mocks base method. -func (m *MockEC2) GetIpamResourceCidrsPagesWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 func(*ec2.GetIpamResourceCidrsOutput, 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, "GetIpamResourceCidrsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetIpamResourceCidrsPagesWithContext indicates an expected call of GetIpamResourceCidrsPagesWithContext. -func (mr *MockEC2MockRecorder) GetIpamResourceCidrsPagesWithContext(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, "GetIpamResourceCidrsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamResourceCidrsPagesWithContext), varargs...) -} - -// GetIpamResourceCidrsRequest mocks base method. -func (m *MockEC2) GetIpamResourceCidrsRequest(arg0 *ec2.GetIpamResourceCidrsInput) (*request.Request, *ec2.GetIpamResourceCidrsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetIpamResourceCidrsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetIpamResourceCidrsOutput) - return ret0, ret1 -} - -// GetIpamResourceCidrsRequest indicates an expected call of GetIpamResourceCidrsRequest. -func (mr *MockEC2MockRecorder) GetIpamResourceCidrsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIpamResourceCidrsRequest", reflect.TypeOf((*MockEC2)(nil).GetIpamResourceCidrsRequest), arg0) -} - -// GetIpamResourceCidrsWithContext mocks base method. -func (m *MockEC2) GetIpamResourceCidrsWithContext(arg0 context.Context, arg1 *ec2.GetIpamResourceCidrsInput, arg2 ...request.Option) (*ec2.GetIpamResourceCidrsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetIpamResourceCidrsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetIpamResourceCidrsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetIpamResourceCidrsWithContext indicates an expected call of GetIpamResourceCidrsWithContext. -func (mr *MockEC2MockRecorder) GetIpamResourceCidrsWithContext(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, "GetIpamResourceCidrsWithContext", reflect.TypeOf((*MockEC2)(nil).GetIpamResourceCidrsWithContext), varargs...) -} - -// GetLaunchTemplateData mocks base method. -func (m *MockEC2) GetLaunchTemplateData(arg0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLaunchTemplateData", arg0) - ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLaunchTemplateData indicates an expected call of GetLaunchTemplateData. -func (mr *MockEC2MockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2)(nil).GetLaunchTemplateData), arg0) -} - -// GetLaunchTemplateDataRequest mocks base method. -func (m *MockEC2) GetLaunchTemplateDataRequest(arg0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetLaunchTemplateDataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetLaunchTemplateDataOutput) - return ret0, ret1 -} - -// GetLaunchTemplateDataRequest indicates an expected call of GetLaunchTemplateDataRequest. -func (mr *MockEC2MockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2)(nil).GetLaunchTemplateDataRequest), arg0) -} - -// GetLaunchTemplateDataWithContext mocks base method. -func (m *MockEC2) GetLaunchTemplateDataWithContext(arg0 context.Context, arg1 *ec2.GetLaunchTemplateDataInput, arg2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetLaunchTemplateDataWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetLaunchTemplateDataWithContext indicates an expected call of GetLaunchTemplateDataWithContext. -func (mr *MockEC2MockRecorder) GetLaunchTemplateDataWithContext(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, "GetLaunchTemplateDataWithContext", reflect.TypeOf((*MockEC2)(nil).GetLaunchTemplateDataWithContext), varargs...) -} - -// GetManagedPrefixListAssociations mocks base method. -func (m *MockEC2) GetManagedPrefixListAssociations(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*ec2.GetManagedPrefixListAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListAssociations", arg0) - ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetManagedPrefixListAssociations indicates an expected call of GetManagedPrefixListAssociations. -func (mr *MockEC2MockRecorder) GetManagedPrefixListAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociations", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListAssociations), arg0) -} - -// GetManagedPrefixListAssociationsPages mocks base method. -func (m *MockEC2) GetManagedPrefixListAssociationsPages(arg0 *ec2.GetManagedPrefixListAssociationsInput, arg1 func(*ec2.GetManagedPrefixListAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetManagedPrefixListAssociationsPages indicates an expected call of GetManagedPrefixListAssociationsPages. -func (mr *MockEC2MockRecorder) GetManagedPrefixListAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsPages", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListAssociationsPages), arg0, arg1) -} - -// GetManagedPrefixListAssociationsPagesWithContext mocks base method. -func (m *MockEC2) GetManagedPrefixListAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 func(*ec2.GetManagedPrefixListAssociationsOutput, 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, "GetManagedPrefixListAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetManagedPrefixListAssociationsPagesWithContext indicates an expected call of GetManagedPrefixListAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetManagedPrefixListAssociationsPagesWithContext(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, "GetManagedPrefixListAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListAssociationsPagesWithContext), varargs...) -} - -// GetManagedPrefixListAssociationsRequest mocks base method. -func (m *MockEC2) GetManagedPrefixListAssociationsRequest(arg0 *ec2.GetManagedPrefixListAssociationsInput) (*request.Request, *ec2.GetManagedPrefixListAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetManagedPrefixListAssociationsOutput) - return ret0, ret1 -} - -// GetManagedPrefixListAssociationsRequest indicates an expected call of GetManagedPrefixListAssociationsRequest. -func (mr *MockEC2MockRecorder) GetManagedPrefixListAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListAssociationsRequest), arg0) -} - -// GetManagedPrefixListAssociationsWithContext mocks base method. -func (m *MockEC2) GetManagedPrefixListAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListAssociationsInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetManagedPrefixListAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetManagedPrefixListAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetManagedPrefixListAssociationsWithContext indicates an expected call of GetManagedPrefixListAssociationsWithContext. -func (mr *MockEC2MockRecorder) GetManagedPrefixListAssociationsWithContext(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, "GetManagedPrefixListAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListAssociationsWithContext), varargs...) -} - -// GetManagedPrefixListEntries mocks base method. -func (m *MockEC2) GetManagedPrefixListEntries(arg0 *ec2.GetManagedPrefixListEntriesInput) (*ec2.GetManagedPrefixListEntriesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListEntries", arg0) - ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetManagedPrefixListEntries indicates an expected call of GetManagedPrefixListEntries. -func (mr *MockEC2MockRecorder) GetManagedPrefixListEntries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntries", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListEntries), arg0) -} - -// GetManagedPrefixListEntriesPages mocks base method. -func (m *MockEC2) GetManagedPrefixListEntriesPages(arg0 *ec2.GetManagedPrefixListEntriesInput, arg1 func(*ec2.GetManagedPrefixListEntriesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetManagedPrefixListEntriesPages indicates an expected call of GetManagedPrefixListEntriesPages. -func (mr *MockEC2MockRecorder) GetManagedPrefixListEntriesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesPages", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListEntriesPages), arg0, arg1) -} - -// GetManagedPrefixListEntriesPagesWithContext mocks base method. -func (m *MockEC2) GetManagedPrefixListEntriesPagesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 func(*ec2.GetManagedPrefixListEntriesOutput, 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, "GetManagedPrefixListEntriesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetManagedPrefixListEntriesPagesWithContext indicates an expected call of GetManagedPrefixListEntriesPagesWithContext. -func (mr *MockEC2MockRecorder) GetManagedPrefixListEntriesPagesWithContext(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, "GetManagedPrefixListEntriesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListEntriesPagesWithContext), varargs...) -} - -// GetManagedPrefixListEntriesRequest mocks base method. -func (m *MockEC2) GetManagedPrefixListEntriesRequest(arg0 *ec2.GetManagedPrefixListEntriesInput) (*request.Request, *ec2.GetManagedPrefixListEntriesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetManagedPrefixListEntriesOutput) - return ret0, ret1 -} - -// GetManagedPrefixListEntriesRequest indicates an expected call of GetManagedPrefixListEntriesRequest. -func (mr *MockEC2MockRecorder) GetManagedPrefixListEntriesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetManagedPrefixListEntriesRequest", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListEntriesRequest), arg0) -} - -// GetManagedPrefixListEntriesWithContext mocks base method. -func (m *MockEC2) GetManagedPrefixListEntriesWithContext(arg0 context.Context, arg1 *ec2.GetManagedPrefixListEntriesInput, arg2 ...request.Option) (*ec2.GetManagedPrefixListEntriesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetManagedPrefixListEntriesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetManagedPrefixListEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetManagedPrefixListEntriesWithContext indicates an expected call of GetManagedPrefixListEntriesWithContext. -func (mr *MockEC2MockRecorder) GetManagedPrefixListEntriesWithContext(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, "GetManagedPrefixListEntriesWithContext", reflect.TypeOf((*MockEC2)(nil).GetManagedPrefixListEntriesWithContext), varargs...) -} - -// GetNetworkInsightsAccessScopeAnalysisFindings mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindings", arg0) - ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeAnalysisFindings indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindings. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeAnalysisFindings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindings", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeAnalysisFindings), arg0) -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsPages mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg1 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsPages indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsPages. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsPages", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsPages), arg0, arg1) -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 func(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, 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, "GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext(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, "GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsPagesWithContext), varargs...) -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsRequest mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsRequest indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsRequest. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeAnalysisFindingsRequest", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsRequest), arg0) -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsWithContext mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeAnalysisFindingsWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeAnalysisFindingsInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeAnalysisFindingsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeAnalysisFindingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeAnalysisFindingsWithContext indicates an expected call of GetNetworkInsightsAccessScopeAnalysisFindingsWithContext. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeAnalysisFindingsWithContext(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, "GetNetworkInsightsAccessScopeAnalysisFindingsWithContext", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeAnalysisFindingsWithContext), varargs...) -} - -// GetNetworkInsightsAccessScopeContent mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeContent(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContent", arg0) - ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeContent indicates an expected call of GetNetworkInsightsAccessScopeContent. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeContent(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContent", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeContent), arg0) -} - -// GetNetworkInsightsAccessScopeContentRequest mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeContentRequest(arg0 *ec2.GetNetworkInsightsAccessScopeContentInput) (*request.Request, *ec2.GetNetworkInsightsAccessScopeContentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetNetworkInsightsAccessScopeContentOutput) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeContentRequest indicates an expected call of GetNetworkInsightsAccessScopeContentRequest. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeContentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNetworkInsightsAccessScopeContentRequest", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeContentRequest), arg0) -} - -// GetNetworkInsightsAccessScopeContentWithContext mocks base method. -func (m *MockEC2) GetNetworkInsightsAccessScopeContentWithContext(arg0 context.Context, arg1 *ec2.GetNetworkInsightsAccessScopeContentInput, arg2 ...request.Option) (*ec2.GetNetworkInsightsAccessScopeContentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetNetworkInsightsAccessScopeContentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetNetworkInsightsAccessScopeContentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetNetworkInsightsAccessScopeContentWithContext indicates an expected call of GetNetworkInsightsAccessScopeContentWithContext. -func (mr *MockEC2MockRecorder) GetNetworkInsightsAccessScopeContentWithContext(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, "GetNetworkInsightsAccessScopeContentWithContext", reflect.TypeOf((*MockEC2)(nil).GetNetworkInsightsAccessScopeContentWithContext), varargs...) -} - -// GetPasswordData mocks base method. -func (m *MockEC2) GetPasswordData(arg0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPasswordData", arg0) - ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPasswordData indicates an expected call of GetPasswordData. -func (mr *MockEC2MockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2)(nil).GetPasswordData), arg0) -} - -// GetPasswordDataRequest mocks base method. -func (m *MockEC2) GetPasswordDataRequest(arg0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetPasswordDataRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetPasswordDataOutput) - return ret0, ret1 -} - -// GetPasswordDataRequest indicates an expected call of GetPasswordDataRequest. -func (mr *MockEC2MockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2)(nil).GetPasswordDataRequest), arg0) -} - -// GetPasswordDataWithContext mocks base method. -func (m *MockEC2) GetPasswordDataWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.Option) (*ec2.GetPasswordDataOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetPasswordDataWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetPasswordDataWithContext indicates an expected call of GetPasswordDataWithContext. -func (mr *MockEC2MockRecorder) GetPasswordDataWithContext(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, "GetPasswordDataWithContext", reflect.TypeOf((*MockEC2)(nil).GetPasswordDataWithContext), varargs...) -} - -// GetReservedInstancesExchangeQuote mocks base method. -func (m *MockEC2) GetReservedInstancesExchangeQuote(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuote", arg0) - ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetReservedInstancesExchangeQuote indicates an expected call of GetReservedInstancesExchangeQuote. -func (mr *MockEC2MockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2)(nil).GetReservedInstancesExchangeQuote), arg0) -} - -// GetReservedInstancesExchangeQuoteRequest mocks base method. -func (m *MockEC2) GetReservedInstancesExchangeQuoteRequest(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetReservedInstancesExchangeQuoteOutput) - return ret0, ret1 -} - -// GetReservedInstancesExchangeQuoteRequest indicates an expected call of GetReservedInstancesExchangeQuoteRequest. -func (mr *MockEC2MockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2)(nil).GetReservedInstancesExchangeQuoteRequest), arg0) -} - -// GetReservedInstancesExchangeQuoteWithContext mocks base method. -func (m *MockEC2) GetReservedInstancesExchangeQuoteWithContext(arg0 context.Context, arg1 *ec2.GetReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetReservedInstancesExchangeQuoteWithContext indicates an expected call of GetReservedInstancesExchangeQuoteWithContext. -func (mr *MockEC2MockRecorder) GetReservedInstancesExchangeQuoteWithContext(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, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...) -} - -// GetSecurityGroupsForVpc mocks base method. -func (m *MockEC2) GetSecurityGroupsForVpc(arg0 *ec2.GetSecurityGroupsForVpcInput) (*ec2.GetSecurityGroupsForVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSecurityGroupsForVpc", arg0) - ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSecurityGroupsForVpc indicates an expected call of GetSecurityGroupsForVpc. -func (mr *MockEC2MockRecorder) GetSecurityGroupsForVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpc", reflect.TypeOf((*MockEC2)(nil).GetSecurityGroupsForVpc), arg0) -} - -// GetSecurityGroupsForVpcPages mocks base method. -func (m *MockEC2) GetSecurityGroupsForVpcPages(arg0 *ec2.GetSecurityGroupsForVpcInput, arg1 func(*ec2.GetSecurityGroupsForVpcOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetSecurityGroupsForVpcPages indicates an expected call of GetSecurityGroupsForVpcPages. -func (mr *MockEC2MockRecorder) GetSecurityGroupsForVpcPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcPages", reflect.TypeOf((*MockEC2)(nil).GetSecurityGroupsForVpcPages), arg0, arg1) -} - -// GetSecurityGroupsForVpcPagesWithContext mocks base method. -func (m *MockEC2) GetSecurityGroupsForVpcPagesWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 func(*ec2.GetSecurityGroupsForVpcOutput, 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, "GetSecurityGroupsForVpcPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetSecurityGroupsForVpcPagesWithContext indicates an expected call of GetSecurityGroupsForVpcPagesWithContext. -func (mr *MockEC2MockRecorder) GetSecurityGroupsForVpcPagesWithContext(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, "GetSecurityGroupsForVpcPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetSecurityGroupsForVpcPagesWithContext), varargs...) -} - -// GetSecurityGroupsForVpcRequest mocks base method. -func (m *MockEC2) GetSecurityGroupsForVpcRequest(arg0 *ec2.GetSecurityGroupsForVpcInput) (*request.Request, *ec2.GetSecurityGroupsForVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetSecurityGroupsForVpcOutput) - return ret0, ret1 -} - -// GetSecurityGroupsForVpcRequest indicates an expected call of GetSecurityGroupsForVpcRequest. -func (mr *MockEC2MockRecorder) GetSecurityGroupsForVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecurityGroupsForVpcRequest", reflect.TypeOf((*MockEC2)(nil).GetSecurityGroupsForVpcRequest), arg0) -} - -// GetSecurityGroupsForVpcWithContext mocks base method. -func (m *MockEC2) GetSecurityGroupsForVpcWithContext(arg0 context.Context, arg1 *ec2.GetSecurityGroupsForVpcInput, arg2 ...request.Option) (*ec2.GetSecurityGroupsForVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSecurityGroupsForVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetSecurityGroupsForVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSecurityGroupsForVpcWithContext indicates an expected call of GetSecurityGroupsForVpcWithContext. -func (mr *MockEC2MockRecorder) GetSecurityGroupsForVpcWithContext(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, "GetSecurityGroupsForVpcWithContext", reflect.TypeOf((*MockEC2)(nil).GetSecurityGroupsForVpcWithContext), varargs...) -} - -// GetSerialConsoleAccessStatus mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetSerialConsoleAccessStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatus", reflect.TypeOf((*MockEC2)(nil).GetSerialConsoleAccessStatus), arg0) -} - -// GetSerialConsoleAccessStatusRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetSerialConsoleAccessStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSerialConsoleAccessStatusRequest", reflect.TypeOf((*MockEC2)(nil).GetSerialConsoleAccessStatusRequest), arg0) -} - -// GetSerialConsoleAccessStatusWithContext mocks base method. -func (m *MockEC2) GetSerialConsoleAccessStatusWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).GetSerialConsoleAccessStatusWithContext), varargs...) -} - -// GetSnapshotBlockPublicAccessState mocks base method. -func (m *MockEC2) GetSnapshotBlockPublicAccessState(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessState", arg0) - ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSnapshotBlockPublicAccessState indicates an expected call of GetSnapshotBlockPublicAccessState. -func (mr *MockEC2MockRecorder) GetSnapshotBlockPublicAccessState(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessState", reflect.TypeOf((*MockEC2)(nil).GetSnapshotBlockPublicAccessState), arg0) -} - -// GetSnapshotBlockPublicAccessStateRequest mocks base method. -func (m *MockEC2) GetSnapshotBlockPublicAccessStateRequest(arg0 *ec2.GetSnapshotBlockPublicAccessStateInput) (*request.Request, *ec2.GetSnapshotBlockPublicAccessStateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetSnapshotBlockPublicAccessStateOutput) - return ret0, ret1 -} - -// GetSnapshotBlockPublicAccessStateRequest indicates an expected call of GetSnapshotBlockPublicAccessStateRequest. -func (mr *MockEC2MockRecorder) GetSnapshotBlockPublicAccessStateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSnapshotBlockPublicAccessStateRequest", reflect.TypeOf((*MockEC2)(nil).GetSnapshotBlockPublicAccessStateRequest), arg0) -} - -// GetSnapshotBlockPublicAccessStateWithContext mocks base method. -func (m *MockEC2) GetSnapshotBlockPublicAccessStateWithContext(arg0 context.Context, arg1 *ec2.GetSnapshotBlockPublicAccessStateInput, arg2 ...request.Option) (*ec2.GetSnapshotBlockPublicAccessStateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSnapshotBlockPublicAccessStateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetSnapshotBlockPublicAccessStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSnapshotBlockPublicAccessStateWithContext indicates an expected call of GetSnapshotBlockPublicAccessStateWithContext. -func (mr *MockEC2MockRecorder) GetSnapshotBlockPublicAccessStateWithContext(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, "GetSnapshotBlockPublicAccessStateWithContext", reflect.TypeOf((*MockEC2)(nil).GetSnapshotBlockPublicAccessStateWithContext), varargs...) -} - -// GetSpotPlacementScores mocks base method. -func (m *MockEC2) GetSpotPlacementScores(arg0 *ec2.GetSpotPlacementScoresInput) (*ec2.GetSpotPlacementScoresOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSpotPlacementScores", arg0) - ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSpotPlacementScores indicates an expected call of GetSpotPlacementScores. -func (mr *MockEC2MockRecorder) GetSpotPlacementScores(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScores", reflect.TypeOf((*MockEC2)(nil).GetSpotPlacementScores), arg0) -} - -// GetSpotPlacementScoresPages mocks base method. -func (m *MockEC2) GetSpotPlacementScoresPages(arg0 *ec2.GetSpotPlacementScoresInput, arg1 func(*ec2.GetSpotPlacementScoresOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSpotPlacementScoresPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetSpotPlacementScoresPages indicates an expected call of GetSpotPlacementScoresPages. -func (mr *MockEC2MockRecorder) GetSpotPlacementScoresPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresPages", reflect.TypeOf((*MockEC2)(nil).GetSpotPlacementScoresPages), arg0, arg1) -} - -// GetSpotPlacementScoresPagesWithContext mocks base method. -func (m *MockEC2) GetSpotPlacementScoresPagesWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 func(*ec2.GetSpotPlacementScoresOutput, 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, "GetSpotPlacementScoresPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetSpotPlacementScoresPagesWithContext indicates an expected call of GetSpotPlacementScoresPagesWithContext. -func (mr *MockEC2MockRecorder) GetSpotPlacementScoresPagesWithContext(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, "GetSpotPlacementScoresPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetSpotPlacementScoresPagesWithContext), varargs...) -} - -// GetSpotPlacementScoresRequest mocks base method. -func (m *MockEC2) GetSpotPlacementScoresRequest(arg0 *ec2.GetSpotPlacementScoresInput) (*request.Request, *ec2.GetSpotPlacementScoresOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSpotPlacementScoresRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetSpotPlacementScoresOutput) - return ret0, ret1 -} - -// GetSpotPlacementScoresRequest indicates an expected call of GetSpotPlacementScoresRequest. -func (mr *MockEC2MockRecorder) GetSpotPlacementScoresRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpotPlacementScoresRequest", reflect.TypeOf((*MockEC2)(nil).GetSpotPlacementScoresRequest), arg0) -} - -// GetSpotPlacementScoresWithContext mocks base method. -func (m *MockEC2) GetSpotPlacementScoresWithContext(arg0 context.Context, arg1 *ec2.GetSpotPlacementScoresInput, arg2 ...request.Option) (*ec2.GetSpotPlacementScoresOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSpotPlacementScoresWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetSpotPlacementScoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSpotPlacementScoresWithContext indicates an expected call of GetSpotPlacementScoresWithContext. -func (mr *MockEC2MockRecorder) GetSpotPlacementScoresWithContext(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, "GetSpotPlacementScoresWithContext", reflect.TypeOf((*MockEC2)(nil).GetSpotPlacementScoresWithContext), varargs...) -} - -// GetSubnetCidrReservations mocks base method. -func (m *MockEC2) GetSubnetCidrReservations(arg0 *ec2.GetSubnetCidrReservationsInput) (*ec2.GetSubnetCidrReservationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSubnetCidrReservations", arg0) - ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSubnetCidrReservations indicates an expected call of GetSubnetCidrReservations. -func (mr *MockEC2MockRecorder) GetSubnetCidrReservations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservations", reflect.TypeOf((*MockEC2)(nil).GetSubnetCidrReservations), arg0) -} - -// GetSubnetCidrReservationsRequest mocks base method. -func (m *MockEC2) GetSubnetCidrReservationsRequest(arg0 *ec2.GetSubnetCidrReservationsInput) (*request.Request, *ec2.GetSubnetCidrReservationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSubnetCidrReservationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetSubnetCidrReservationsOutput) - return ret0, ret1 -} - -// GetSubnetCidrReservationsRequest indicates an expected call of GetSubnetCidrReservationsRequest. -func (mr *MockEC2MockRecorder) GetSubnetCidrReservationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetCidrReservationsRequest", reflect.TypeOf((*MockEC2)(nil).GetSubnetCidrReservationsRequest), arg0) -} - -// GetSubnetCidrReservationsWithContext mocks base method. -func (m *MockEC2) GetSubnetCidrReservationsWithContext(arg0 context.Context, arg1 *ec2.GetSubnetCidrReservationsInput, arg2 ...request.Option) (*ec2.GetSubnetCidrReservationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSubnetCidrReservationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetSubnetCidrReservationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSubnetCidrReservationsWithContext indicates an expected call of GetSubnetCidrReservationsWithContext. -func (mr *MockEC2MockRecorder) GetSubnetCidrReservationsWithContext(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, "GetSubnetCidrReservationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetSubnetCidrReservationsWithContext), varargs...) -} - -// GetTransitGatewayAttachmentPropagations mocks base method. -func (m *MockEC2) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagations", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayAttachmentPropagations indicates an expected call of GetTransitGatewayAttachmentPropagations. -func (mr *MockEC2MockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayAttachmentPropagations), arg0) -} - -// GetTransitGatewayAttachmentPropagationsPages mocks base method. -func (m *MockEC2) GetTransitGatewayAttachmentPropagationsPages(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayAttachmentPropagationsPages indicates an expected call of GetTransitGatewayAttachmentPropagationsPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1) -} - -// GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, 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, "GetTransitGatewayAttachmentPropagationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayAttachmentPropagationsPagesWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayAttachmentPropagationsPagesWithContext(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, "GetTransitGatewayAttachmentPropagationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayAttachmentPropagationsPagesWithContext), varargs...) -} - -// GetTransitGatewayAttachmentPropagationsRequest mocks base method. -func (m *MockEC2) GetTransitGatewayAttachmentPropagationsRequest(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) - return ret0, ret1 -} - -// GetTransitGatewayAttachmentPropagationsRequest indicates an expected call of GetTransitGatewayAttachmentPropagationsRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0) -} - -// GetTransitGatewayAttachmentPropagationsWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayAttachmentPropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayAttachmentPropagationsWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayAttachmentPropagationsWithContext(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, "GetTransitGatewayAttachmentPropagationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayAttachmentPropagationsWithContext), varargs...) -} - -// GetTransitGatewayMulticastDomainAssociations mocks base method. -func (m *MockEC2) GetTransitGatewayMulticastDomainAssociations(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociations", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayMulticastDomainAssociations indicates an expected call of GetTransitGatewayMulticastDomainAssociations. -func (mr *MockEC2MockRecorder) GetTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayMulticastDomainAssociations), arg0) -} - -// GetTransitGatewayMulticastDomainAssociationsPages mocks base method. -func (m *MockEC2) GetTransitGatewayMulticastDomainAssociationsPages(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg1 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayMulticastDomainAssociationsPages indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayMulticastDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayMulticastDomainAssociationsPages), arg0, arg1) -} - -// GetTransitGatewayMulticastDomainAssociationsPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 func(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, 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, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayMulticastDomainAssociationsPagesWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(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, "GetTransitGatewayMulticastDomainAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayMulticastDomainAssociationsPagesWithContext), varargs...) -} - -// GetTransitGatewayMulticastDomainAssociationsRequest mocks base method. -func (m *MockEC2) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 *ec2.GetTransitGatewayMulticastDomainAssociationsInput) (*request.Request, *ec2.GetTransitGatewayMulticastDomainAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) - return ret0, ret1 -} - -// GetTransitGatewayMulticastDomainAssociationsRequest indicates an expected call of GetTransitGatewayMulticastDomainAssociationsRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayMulticastDomainAssociationsRequest), arg0) -} - -// GetTransitGatewayMulticastDomainAssociationsWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayMulticastDomainAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayMulticastDomainAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayMulticastDomainAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayMulticastDomainAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayMulticastDomainAssociationsWithContext indicates an expected call of GetTransitGatewayMulticastDomainAssociationsWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayMulticastDomainAssociationsWithContext(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, "GetTransitGatewayMulticastDomainAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayMulticastDomainAssociationsWithContext), varargs...) -} - -// GetTransitGatewayPolicyTableAssociations mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableAssociations(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociations", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableAssociations indicates an expected call of GetTransitGatewayPolicyTableAssociations. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociations", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableAssociations), arg0) -} - -// GetTransitGatewayPolicyTableAssociationsPages mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableAssociationsPages(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayPolicyTableAssociationsPages indicates an expected call of GetTransitGatewayPolicyTableAssociationsPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableAssociationsPages), arg0, arg1) -} - -// GetTransitGatewayPolicyTableAssociationsPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayPolicyTableAssociationsOutput, 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, "GetTransitGatewayPolicyTableAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayPolicyTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayPolicyTableAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableAssociationsPagesWithContext(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, "GetTransitGatewayPolicyTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableAssociationsPagesWithContext), varargs...) -} - -// GetTransitGatewayPolicyTableAssociationsRequest mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableAssociationsRequest(arg0 *ec2.GetTransitGatewayPolicyTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableAssociationsRequest indicates an expected call of GetTransitGatewayPolicyTableAssociationsRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableAssociationsRequest), arg0) -} - -// GetTransitGatewayPolicyTableAssociationsWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableAssociationsWithContext indicates an expected call of GetTransitGatewayPolicyTableAssociationsWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableAssociationsWithContext(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, "GetTransitGatewayPolicyTableAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableAssociationsWithContext), varargs...) -} - -// GetTransitGatewayPolicyTableEntries mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableEntries(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntries", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableEntries indicates an expected call of GetTransitGatewayPolicyTableEntries. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableEntries(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntries", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableEntries), arg0) -} - -// GetTransitGatewayPolicyTableEntriesRequest mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableEntriesRequest(arg0 *ec2.GetTransitGatewayPolicyTableEntriesInput) (*request.Request, *ec2.GetTransitGatewayPolicyTableEntriesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayPolicyTableEntriesOutput) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableEntriesRequest indicates an expected call of GetTransitGatewayPolicyTableEntriesRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableEntriesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPolicyTableEntriesRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableEntriesRequest), arg0) -} - -// GetTransitGatewayPolicyTableEntriesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayPolicyTableEntriesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPolicyTableEntriesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPolicyTableEntriesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayPolicyTableEntriesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPolicyTableEntriesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPolicyTableEntriesWithContext indicates an expected call of GetTransitGatewayPolicyTableEntriesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayPolicyTableEntriesWithContext(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, "GetTransitGatewayPolicyTableEntriesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPolicyTableEntriesWithContext), varargs...) -} - -// GetTransitGatewayPrefixListReferences mocks base method. -func (m *MockEC2) GetTransitGatewayPrefixListReferences(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferences", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPrefixListReferences indicates an expected call of GetTransitGatewayPrefixListReferences. -func (mr *MockEC2MockRecorder) GetTransitGatewayPrefixListReferences(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferences", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPrefixListReferences), arg0) -} - -// GetTransitGatewayPrefixListReferencesPages mocks base method. -func (m *MockEC2) GetTransitGatewayPrefixListReferencesPages(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput, arg1 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayPrefixListReferencesPages indicates an expected call of GetTransitGatewayPrefixListReferencesPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayPrefixListReferencesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPrefixListReferencesPages), arg0, arg1) -} - -// GetTransitGatewayPrefixListReferencesPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayPrefixListReferencesPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 func(*ec2.GetTransitGatewayPrefixListReferencesOutput, 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, "GetTransitGatewayPrefixListReferencesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayPrefixListReferencesPagesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayPrefixListReferencesPagesWithContext(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, "GetTransitGatewayPrefixListReferencesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPrefixListReferencesPagesWithContext), varargs...) -} - -// GetTransitGatewayPrefixListReferencesRequest mocks base method. -func (m *MockEC2) GetTransitGatewayPrefixListReferencesRequest(arg0 *ec2.GetTransitGatewayPrefixListReferencesInput) (*request.Request, *ec2.GetTransitGatewayPrefixListReferencesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayPrefixListReferencesOutput) - return ret0, ret1 -} - -// GetTransitGatewayPrefixListReferencesRequest indicates an expected call of GetTransitGatewayPrefixListReferencesRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayPrefixListReferencesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayPrefixListReferencesRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPrefixListReferencesRequest), arg0) -} - -// GetTransitGatewayPrefixListReferencesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayPrefixListReferencesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayPrefixListReferencesInput, arg2 ...request.Option) (*ec2.GetTransitGatewayPrefixListReferencesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayPrefixListReferencesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayPrefixListReferencesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayPrefixListReferencesWithContext indicates an expected call of GetTransitGatewayPrefixListReferencesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayPrefixListReferencesWithContext(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, "GetTransitGatewayPrefixListReferencesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayPrefixListReferencesWithContext), varargs...) -} - -// GetTransitGatewayRouteTableAssociations mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTableAssociations(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociations", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayRouteTableAssociations indicates an expected call of GetTransitGatewayRouteTableAssociations. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTableAssociations), arg0) -} - -// GetTransitGatewayRouteTableAssociationsPages mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTableAssociationsPages(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayRouteTableAssociationsPages indicates an expected call of GetTransitGatewayRouteTableAssociationsPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1) -} - -// GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, 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, "GetTransitGatewayRouteTableAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayRouteTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTableAssociationsPagesWithContext(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, "GetTransitGatewayRouteTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTableAssociationsPagesWithContext), varargs...) -} - -// GetTransitGatewayRouteTableAssociationsRequest mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTableAssociationsRequest(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) - return ret0, ret1 -} - -// GetTransitGatewayRouteTableAssociationsRequest indicates an expected call of GetTransitGatewayRouteTableAssociationsRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0) -} - -// GetTransitGatewayRouteTableAssociationsWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTableAssociationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayRouteTableAssociationsWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTableAssociationsWithContext(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, "GetTransitGatewayRouteTableAssociationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTableAssociationsWithContext), varargs...) -} - -// GetTransitGatewayRouteTablePropagations mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTablePropagations(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagations", arg0) - ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayRouteTablePropagations indicates an expected call of GetTransitGatewayRouteTablePropagations. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTablePropagations), arg0) -} - -// GetTransitGatewayRouteTablePropagationsPages mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTablePropagationsPages(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayRouteTablePropagationsPages indicates an expected call of GetTransitGatewayRouteTablePropagationsPages. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1) -} - -// GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, 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, "GetTransitGatewayRouteTablePropagationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetTransitGatewayRouteTablePropagationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsPagesWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTablePropagationsPagesWithContext(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, "GetTransitGatewayRouteTablePropagationsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTablePropagationsPagesWithContext), varargs...) -} - -// GetTransitGatewayRouteTablePropagationsRequest mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTablePropagationsRequest(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) - return ret0, ret1 -} - -// GetTransitGatewayRouteTablePropagationsRequest indicates an expected call of GetTransitGatewayRouteTablePropagationsRequest. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0) -} - -// GetTransitGatewayRouteTablePropagationsWithContext mocks base method. -func (m *MockEC2) GetTransitGatewayRouteTablePropagationsWithContext(arg0 context.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTransitGatewayRouteTablePropagationsWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsWithContext. -func (mr *MockEC2MockRecorder) GetTransitGatewayRouteTablePropagationsWithContext(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, "GetTransitGatewayRouteTablePropagationsWithContext", reflect.TypeOf((*MockEC2)(nil).GetTransitGatewayRouteTablePropagationsWithContext), varargs...) -} - -// GetVerifiedAccessEndpointPolicy mocks base method. -func (m *MockEC2) GetVerifiedAccessEndpointPolicy(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicy", arg0) - ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVerifiedAccessEndpointPolicy indicates an expected call of GetVerifiedAccessEndpointPolicy. -func (mr *MockEC2MockRecorder) GetVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessEndpointPolicy), arg0) -} - -// GetVerifiedAccessEndpointPolicyRequest mocks base method. -func (m *MockEC2) GetVerifiedAccessEndpointPolicyRequest(arg0 *ec2.GetVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.GetVerifiedAccessEndpointPolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetVerifiedAccessEndpointPolicyOutput) - return ret0, ret1 -} - -// GetVerifiedAccessEndpointPolicyRequest indicates an expected call of GetVerifiedAccessEndpointPolicyRequest. -func (mr *MockEC2MockRecorder) GetVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessEndpointPolicyRequest), arg0) -} - -// GetVerifiedAccessEndpointPolicyWithContext mocks base method. -func (m *MockEC2) GetVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessEndpointPolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetVerifiedAccessEndpointPolicyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetVerifiedAccessEndpointPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVerifiedAccessEndpointPolicyWithContext indicates an expected call of GetVerifiedAccessEndpointPolicyWithContext. -func (mr *MockEC2MockRecorder) GetVerifiedAccessEndpointPolicyWithContext(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, "GetVerifiedAccessEndpointPolicyWithContext", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessEndpointPolicyWithContext), varargs...) -} - -// GetVerifiedAccessGroupPolicy mocks base method. -func (m *MockEC2) GetVerifiedAccessGroupPolicy(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicy", arg0) - ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVerifiedAccessGroupPolicy indicates an expected call of GetVerifiedAccessGroupPolicy. -func (mr *MockEC2MockRecorder) GetVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessGroupPolicy), arg0) -} - -// GetVerifiedAccessGroupPolicyRequest mocks base method. -func (m *MockEC2) GetVerifiedAccessGroupPolicyRequest(arg0 *ec2.GetVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.GetVerifiedAccessGroupPolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetVerifiedAccessGroupPolicyOutput) - return ret0, ret1 -} - -// GetVerifiedAccessGroupPolicyRequest indicates an expected call of GetVerifiedAccessGroupPolicyRequest. -func (mr *MockEC2MockRecorder) GetVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessGroupPolicyRequest), arg0) -} - -// GetVerifiedAccessGroupPolicyWithContext mocks base method. -func (m *MockEC2) GetVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.GetVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.GetVerifiedAccessGroupPolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetVerifiedAccessGroupPolicyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetVerifiedAccessGroupPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVerifiedAccessGroupPolicyWithContext indicates an expected call of GetVerifiedAccessGroupPolicyWithContext. -func (mr *MockEC2MockRecorder) GetVerifiedAccessGroupPolicyWithContext(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, "GetVerifiedAccessGroupPolicyWithContext", reflect.TypeOf((*MockEC2)(nil).GetVerifiedAccessGroupPolicyWithContext), varargs...) -} - -// GetVpnConnectionDeviceSampleConfiguration mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceSampleConfiguration(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfiguration", arg0) - ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVpnConnectionDeviceSampleConfiguration indicates an expected call of GetVpnConnectionDeviceSampleConfiguration. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceSampleConfiguration(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfiguration", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceSampleConfiguration), arg0) -} - -// GetVpnConnectionDeviceSampleConfigurationRequest mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 *ec2.GetVpnConnectionDeviceSampleConfigurationInput) (*request.Request, *ec2.GetVpnConnectionDeviceSampleConfigurationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput) - return ret0, ret1 -} - -// GetVpnConnectionDeviceSampleConfigurationRequest indicates an expected call of GetVpnConnectionDeviceSampleConfigurationRequest. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceSampleConfigurationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceSampleConfigurationRequest", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceSampleConfigurationRequest), arg0) -} - -// GetVpnConnectionDeviceSampleConfigurationWithContext mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceSampleConfigurationWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceSampleConfigurationInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceSampleConfigurationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceSampleConfigurationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceSampleConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVpnConnectionDeviceSampleConfigurationWithContext indicates an expected call of GetVpnConnectionDeviceSampleConfigurationWithContext. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceSampleConfigurationWithContext(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, "GetVpnConnectionDeviceSampleConfigurationWithContext", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceSampleConfigurationWithContext), varargs...) -} - -// GetVpnConnectionDeviceTypes mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceTypes(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*ec2.GetVpnConnectionDeviceTypesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypes", arg0) - ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVpnConnectionDeviceTypes indicates an expected call of GetVpnConnectionDeviceTypes. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceTypes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypes", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceTypes), arg0) -} - -// GetVpnConnectionDeviceTypesPages mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceTypesPages(arg0 *ec2.GetVpnConnectionDeviceTypesInput, arg1 func(*ec2.GetVpnConnectionDeviceTypesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetVpnConnectionDeviceTypesPages indicates an expected call of GetVpnConnectionDeviceTypesPages. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceTypesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesPages", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceTypesPages), arg0, arg1) -} - -// GetVpnConnectionDeviceTypesPagesWithContext mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceTypesPagesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 func(*ec2.GetVpnConnectionDeviceTypesOutput, 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, "GetVpnConnectionDeviceTypesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// GetVpnConnectionDeviceTypesPagesWithContext indicates an expected call of GetVpnConnectionDeviceTypesPagesWithContext. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceTypesPagesWithContext(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, "GetVpnConnectionDeviceTypesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceTypesPagesWithContext), varargs...) -} - -// GetVpnConnectionDeviceTypesRequest mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceTypesRequest(arg0 *ec2.GetVpnConnectionDeviceTypesInput) (*request.Request, *ec2.GetVpnConnectionDeviceTypesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.GetVpnConnectionDeviceTypesOutput) - return ret0, ret1 -} - -// GetVpnConnectionDeviceTypesRequest indicates an expected call of GetVpnConnectionDeviceTypesRequest. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceTypesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnConnectionDeviceTypesRequest", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceTypesRequest), arg0) -} - -// GetVpnConnectionDeviceTypesWithContext mocks base method. -func (m *MockEC2) GetVpnConnectionDeviceTypesWithContext(arg0 context.Context, arg1 *ec2.GetVpnConnectionDeviceTypesInput, arg2 ...request.Option) (*ec2.GetVpnConnectionDeviceTypesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetVpnConnectionDeviceTypesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.GetVpnConnectionDeviceTypesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetVpnConnectionDeviceTypesWithContext indicates an expected call of GetVpnConnectionDeviceTypesWithContext. -func (mr *MockEC2MockRecorder) GetVpnConnectionDeviceTypesWithContext(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, "GetVpnConnectionDeviceTypesWithContext", reflect.TypeOf((*MockEC2)(nil).GetVpnConnectionDeviceTypesWithContext), varargs...) -} - -// GetVpnTunnelReplacementStatus mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetVpnTunnelReplacementStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatus", reflect.TypeOf((*MockEC2)(nil).GetVpnTunnelReplacementStatus), arg0) -} - -// GetVpnTunnelReplacementStatusRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) GetVpnTunnelReplacementStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVpnTunnelReplacementStatusRequest", reflect.TypeOf((*MockEC2)(nil).GetVpnTunnelReplacementStatusRequest), arg0) -} - -// GetVpnTunnelReplacementStatusWithContext mocks base method. -func (m *MockEC2) GetVpnTunnelReplacementStatusWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).GetVpnTunnelReplacementStatusWithContext), varargs...) -} - -// ImportClientVpnClientCertificateRevocationList mocks base method. -func (m *MockEC2) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationList", arg0) - ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportClientVpnClientCertificateRevocationList indicates an expected call of ImportClientVpnClientCertificateRevocationList. -func (mr *MockEC2MockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2)(nil).ImportClientVpnClientCertificateRevocationList), arg0) -} - -// ImportClientVpnClientCertificateRevocationListRequest mocks base method. -func (m *MockEC2) ImportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) - return ret0, ret1 -} - -// ImportClientVpnClientCertificateRevocationListRequest indicates an expected call of ImportClientVpnClientCertificateRevocationListRequest. -func (mr *MockEC2MockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0) -} - -// ImportClientVpnClientCertificateRevocationListWithContext mocks base method. -func (m *MockEC2) ImportClientVpnClientCertificateRevocationListWithContext(arg0 context.Context, arg1 *ec2.ImportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ImportClientVpnClientCertificateRevocationListWithContext. -func (mr *MockEC2MockRecorder) ImportClientVpnClientCertificateRevocationListWithContext(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, "ImportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2)(nil).ImportClientVpnClientCertificateRevocationListWithContext), varargs...) -} - -// ImportImage mocks base method. -func (m *MockEC2) ImportImage(arg0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportImage", arg0) - ret0, _ := ret[0].(*ec2.ImportImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportImage indicates an expected call of ImportImage. -func (mr *MockEC2MockRecorder) ImportImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2)(nil).ImportImage), arg0) -} - -// ImportImageRequest mocks base method. -func (m *MockEC2) ImportImageRequest(arg0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportImageOutput) - return ret0, ret1 -} - -// ImportImageRequest indicates an expected call of ImportImageRequest. -func (mr *MockEC2MockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2)(nil).ImportImageRequest), arg0) -} - -// ImportImageWithContext mocks base method. -func (m *MockEC2) ImportImageWithContext(arg0 context.Context, arg1 *ec2.ImportImageInput, arg2 ...request.Option) (*ec2.ImportImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportImageWithContext indicates an expected call of ImportImageWithContext. -func (mr *MockEC2MockRecorder) ImportImageWithContext(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, "ImportImageWithContext", reflect.TypeOf((*MockEC2)(nil).ImportImageWithContext), varargs...) -} - -// ImportInstance mocks base method. -func (m *MockEC2) ImportInstance(arg0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportInstance", arg0) - ret0, _ := ret[0].(*ec2.ImportInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportInstance indicates an expected call of ImportInstance. -func (mr *MockEC2MockRecorder) ImportInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2)(nil).ImportInstance), arg0) -} - -// ImportInstanceRequest mocks base method. -func (m *MockEC2) ImportInstanceRequest(arg0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportInstanceOutput) - return ret0, ret1 -} - -// ImportInstanceRequest indicates an expected call of ImportInstanceRequest. -func (mr *MockEC2MockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2)(nil).ImportInstanceRequest), arg0) -} - -// ImportInstanceWithContext mocks base method. -func (m *MockEC2) ImportInstanceWithContext(arg0 context.Context, arg1 *ec2.ImportInstanceInput, arg2 ...request.Option) (*ec2.ImportInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportInstanceWithContext indicates an expected call of ImportInstanceWithContext. -func (mr *MockEC2MockRecorder) ImportInstanceWithContext(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, "ImportInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).ImportInstanceWithContext), varargs...) -} - -// ImportKeyPair mocks base method. -func (m *MockEC2) ImportKeyPair(arg0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportKeyPair", arg0) - ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportKeyPair indicates an expected call of ImportKeyPair. -func (mr *MockEC2MockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2)(nil).ImportKeyPair), arg0) -} - -// ImportKeyPairRequest mocks base method. -func (m *MockEC2) ImportKeyPairRequest(arg0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportKeyPairRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportKeyPairOutput) - return ret0, ret1 -} - -// ImportKeyPairRequest indicates an expected call of ImportKeyPairRequest. -func (mr *MockEC2MockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2)(nil).ImportKeyPairRequest), arg0) -} - -// ImportKeyPairWithContext mocks base method. -func (m *MockEC2) ImportKeyPairWithContext(arg0 context.Context, arg1 *ec2.ImportKeyPairInput, arg2 ...request.Option) (*ec2.ImportKeyPairOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportKeyPairWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportKeyPairWithContext indicates an expected call of ImportKeyPairWithContext. -func (mr *MockEC2MockRecorder) ImportKeyPairWithContext(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, "ImportKeyPairWithContext", reflect.TypeOf((*MockEC2)(nil).ImportKeyPairWithContext), varargs...) -} - -// ImportSnapshot mocks base method. -func (m *MockEC2) ImportSnapshot(arg0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportSnapshot", arg0) - ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportSnapshot indicates an expected call of ImportSnapshot. -func (mr *MockEC2MockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2)(nil).ImportSnapshot), arg0) -} - -// ImportSnapshotRequest mocks base method. -func (m *MockEC2) ImportSnapshotRequest(arg0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportSnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportSnapshotOutput) - return ret0, ret1 -} - -// ImportSnapshotRequest indicates an expected call of ImportSnapshotRequest. -func (mr *MockEC2MockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2)(nil).ImportSnapshotRequest), arg0) -} - -// ImportSnapshotWithContext mocks base method. -func (m *MockEC2) ImportSnapshotWithContext(arg0 context.Context, arg1 *ec2.ImportSnapshotInput, arg2 ...request.Option) (*ec2.ImportSnapshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportSnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportSnapshotWithContext indicates an expected call of ImportSnapshotWithContext. -func (mr *MockEC2MockRecorder) ImportSnapshotWithContext(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, "ImportSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).ImportSnapshotWithContext), varargs...) -} - -// ImportVolume mocks base method. -func (m *MockEC2) ImportVolume(arg0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportVolume", arg0) - ret0, _ := ret[0].(*ec2.ImportVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportVolume indicates an expected call of ImportVolume. -func (mr *MockEC2MockRecorder) ImportVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2)(nil).ImportVolume), arg0) -} - -// ImportVolumeRequest mocks base method. -func (m *MockEC2) ImportVolumeRequest(arg0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ImportVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ImportVolumeOutput) - return ret0, ret1 -} - -// ImportVolumeRequest indicates an expected call of ImportVolumeRequest. -func (mr *MockEC2MockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2)(nil).ImportVolumeRequest), arg0) -} - -// ImportVolumeWithContext mocks base method. -func (m *MockEC2) ImportVolumeWithContext(arg0 context.Context, arg1 *ec2.ImportVolumeInput, arg2 ...request.Option) (*ec2.ImportVolumeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ImportVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ImportVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ImportVolumeWithContext indicates an expected call of ImportVolumeWithContext. -func (mr *MockEC2MockRecorder) ImportVolumeWithContext(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, "ImportVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).ImportVolumeWithContext), varargs...) -} - -// ListImagesInRecycleBin mocks base method. -func (m *MockEC2) ListImagesInRecycleBin(arg0 *ec2.ListImagesInRecycleBinInput) (*ec2.ListImagesInRecycleBinOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListImagesInRecycleBin", arg0) - ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListImagesInRecycleBin indicates an expected call of ListImagesInRecycleBin. -func (mr *MockEC2MockRecorder) ListImagesInRecycleBin(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBin", reflect.TypeOf((*MockEC2)(nil).ListImagesInRecycleBin), arg0) -} - -// ListImagesInRecycleBinPages mocks base method. -func (m *MockEC2) ListImagesInRecycleBinPages(arg0 *ec2.ListImagesInRecycleBinInput, arg1 func(*ec2.ListImagesInRecycleBinOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListImagesInRecycleBinPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListImagesInRecycleBinPages indicates an expected call of ListImagesInRecycleBinPages. -func (mr *MockEC2MockRecorder) ListImagesInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinPages", reflect.TypeOf((*MockEC2)(nil).ListImagesInRecycleBinPages), arg0, arg1) -} - -// ListImagesInRecycleBinPagesWithContext mocks base method. -func (m *MockEC2) ListImagesInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 func(*ec2.ListImagesInRecycleBinOutput, 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, "ListImagesInRecycleBinPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListImagesInRecycleBinPagesWithContext indicates an expected call of ListImagesInRecycleBinPagesWithContext. -func (mr *MockEC2MockRecorder) ListImagesInRecycleBinPagesWithContext(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, "ListImagesInRecycleBinPagesWithContext", reflect.TypeOf((*MockEC2)(nil).ListImagesInRecycleBinPagesWithContext), varargs...) -} - -// ListImagesInRecycleBinRequest mocks base method. -func (m *MockEC2) ListImagesInRecycleBinRequest(arg0 *ec2.ListImagesInRecycleBinInput) (*request.Request, *ec2.ListImagesInRecycleBinOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListImagesInRecycleBinRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ListImagesInRecycleBinOutput) - return ret0, ret1 -} - -// ListImagesInRecycleBinRequest indicates an expected call of ListImagesInRecycleBinRequest. -func (mr *MockEC2MockRecorder) ListImagesInRecycleBinRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImagesInRecycleBinRequest", reflect.TypeOf((*MockEC2)(nil).ListImagesInRecycleBinRequest), arg0) -} - -// ListImagesInRecycleBinWithContext mocks base method. -func (m *MockEC2) ListImagesInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListImagesInRecycleBinInput, arg2 ...request.Option) (*ec2.ListImagesInRecycleBinOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListImagesInRecycleBinWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ListImagesInRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListImagesInRecycleBinWithContext indicates an expected call of ListImagesInRecycleBinWithContext. -func (mr *MockEC2MockRecorder) ListImagesInRecycleBinWithContext(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, "ListImagesInRecycleBinWithContext", reflect.TypeOf((*MockEC2)(nil).ListImagesInRecycleBinWithContext), varargs...) -} - -// ListSnapshotsInRecycleBin mocks base method. -func (m *MockEC2) ListSnapshotsInRecycleBin(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*ec2.ListSnapshotsInRecycleBinOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBin", arg0) - ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSnapshotsInRecycleBin indicates an expected call of ListSnapshotsInRecycleBin. -func (mr *MockEC2MockRecorder) ListSnapshotsInRecycleBin(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBin", reflect.TypeOf((*MockEC2)(nil).ListSnapshotsInRecycleBin), arg0) -} - -// ListSnapshotsInRecycleBinPages mocks base method. -func (m *MockEC2) ListSnapshotsInRecycleBinPages(arg0 *ec2.ListSnapshotsInRecycleBinInput, arg1 func(*ec2.ListSnapshotsInRecycleBinOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSnapshotsInRecycleBinPages indicates an expected call of ListSnapshotsInRecycleBinPages. -func (mr *MockEC2MockRecorder) ListSnapshotsInRecycleBinPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinPages", reflect.TypeOf((*MockEC2)(nil).ListSnapshotsInRecycleBinPages), arg0, arg1) -} - -// ListSnapshotsInRecycleBinPagesWithContext mocks base method. -func (m *MockEC2) ListSnapshotsInRecycleBinPagesWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 func(*ec2.ListSnapshotsInRecycleBinOutput, 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, "ListSnapshotsInRecycleBinPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListSnapshotsInRecycleBinPagesWithContext indicates an expected call of ListSnapshotsInRecycleBinPagesWithContext. -func (mr *MockEC2MockRecorder) ListSnapshotsInRecycleBinPagesWithContext(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, "ListSnapshotsInRecycleBinPagesWithContext", reflect.TypeOf((*MockEC2)(nil).ListSnapshotsInRecycleBinPagesWithContext), varargs...) -} - -// ListSnapshotsInRecycleBinRequest mocks base method. -func (m *MockEC2) ListSnapshotsInRecycleBinRequest(arg0 *ec2.ListSnapshotsInRecycleBinInput) (*request.Request, *ec2.ListSnapshotsInRecycleBinOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ListSnapshotsInRecycleBinOutput) - return ret0, ret1 -} - -// ListSnapshotsInRecycleBinRequest indicates an expected call of ListSnapshotsInRecycleBinRequest. -func (mr *MockEC2MockRecorder) ListSnapshotsInRecycleBinRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSnapshotsInRecycleBinRequest", reflect.TypeOf((*MockEC2)(nil).ListSnapshotsInRecycleBinRequest), arg0) -} - -// ListSnapshotsInRecycleBinWithContext mocks base method. -func (m *MockEC2) ListSnapshotsInRecycleBinWithContext(arg0 context.Context, arg1 *ec2.ListSnapshotsInRecycleBinInput, arg2 ...request.Option) (*ec2.ListSnapshotsInRecycleBinOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListSnapshotsInRecycleBinWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ListSnapshotsInRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListSnapshotsInRecycleBinWithContext indicates an expected call of ListSnapshotsInRecycleBinWithContext. -func (mr *MockEC2MockRecorder) ListSnapshotsInRecycleBinWithContext(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, "ListSnapshotsInRecycleBinWithContext", reflect.TypeOf((*MockEC2)(nil).ListSnapshotsInRecycleBinWithContext), varargs...) -} - -// LockSnapshot mocks base method. -func (m *MockEC2) LockSnapshot(arg0 *ec2.LockSnapshotInput) (*ec2.LockSnapshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LockSnapshot", arg0) - ret0, _ := ret[0].(*ec2.LockSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LockSnapshot indicates an expected call of LockSnapshot. -func (mr *MockEC2MockRecorder) LockSnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshot", reflect.TypeOf((*MockEC2)(nil).LockSnapshot), arg0) -} - -// LockSnapshotRequest mocks base method. -func (m *MockEC2) LockSnapshotRequest(arg0 *ec2.LockSnapshotInput) (*request.Request, *ec2.LockSnapshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "LockSnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.LockSnapshotOutput) - return ret0, ret1 -} - -// LockSnapshotRequest indicates an expected call of LockSnapshotRequest. -func (mr *MockEC2MockRecorder) LockSnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LockSnapshotRequest", reflect.TypeOf((*MockEC2)(nil).LockSnapshotRequest), arg0) -} - -// LockSnapshotWithContext mocks base method. -func (m *MockEC2) LockSnapshotWithContext(arg0 context.Context, arg1 *ec2.LockSnapshotInput, arg2 ...request.Option) (*ec2.LockSnapshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "LockSnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.LockSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// LockSnapshotWithContext indicates an expected call of LockSnapshotWithContext. -func (mr *MockEC2MockRecorder) LockSnapshotWithContext(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, "LockSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).LockSnapshotWithContext), varargs...) -} - -// ModifyAddressAttribute mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ModifyAddressAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyAddressAttribute), arg0) -} - -// ModifyAddressAttributeRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ModifyAddressAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAddressAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyAddressAttributeRequest), arg0) -} - -// ModifyAddressAttributeWithContext mocks base method. -func (m *MockEC2) ModifyAddressAttributeWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).ModifyAddressAttributeWithContext), varargs...) -} - -// ModifyAvailabilityZoneGroup mocks base method. -func (m *MockEC2) ModifyAvailabilityZoneGroup(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*ec2.ModifyAvailabilityZoneGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroup", arg0) - ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyAvailabilityZoneGroup indicates an expected call of ModifyAvailabilityZoneGroup. -func (mr *MockEC2MockRecorder) ModifyAvailabilityZoneGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroup", reflect.TypeOf((*MockEC2)(nil).ModifyAvailabilityZoneGroup), arg0) -} - -// ModifyAvailabilityZoneGroupRequest mocks base method. -func (m *MockEC2) ModifyAvailabilityZoneGroupRequest(arg0 *ec2.ModifyAvailabilityZoneGroupInput) (*request.Request, *ec2.ModifyAvailabilityZoneGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyAvailabilityZoneGroupOutput) - return ret0, ret1 -} - -// ModifyAvailabilityZoneGroupRequest indicates an expected call of ModifyAvailabilityZoneGroupRequest. -func (mr *MockEC2MockRecorder) ModifyAvailabilityZoneGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupRequest", reflect.TypeOf((*MockEC2)(nil).ModifyAvailabilityZoneGroupRequest), arg0) -} - -// ModifyAvailabilityZoneGroupWithContext mocks base method. -func (m *MockEC2) ModifyAvailabilityZoneGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyAvailabilityZoneGroupInput, arg2 ...request.Option) (*ec2.ModifyAvailabilityZoneGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyAvailabilityZoneGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyAvailabilityZoneGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyAvailabilityZoneGroupWithContext indicates an expected call of ModifyAvailabilityZoneGroupWithContext. -func (mr *MockEC2MockRecorder) ModifyAvailabilityZoneGroupWithContext(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, "ModifyAvailabilityZoneGroupWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyAvailabilityZoneGroupWithContext), varargs...) -} - -// ModifyCapacityReservation mocks base method. -func (m *MockEC2) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0) - ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation. -func (mr *MockEC2MockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservation), arg0) -} - -// ModifyCapacityReservationFleet mocks base method. -func (m *MockEC2) ModifyCapacityReservationFleet(arg0 *ec2.ModifyCapacityReservationFleetInput) (*ec2.ModifyCapacityReservationFleetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyCapacityReservationFleet", arg0) - ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyCapacityReservationFleet indicates an expected call of ModifyCapacityReservationFleet. -func (mr *MockEC2MockRecorder) ModifyCapacityReservationFleet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleet", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservationFleet), arg0) -} - -// ModifyCapacityReservationFleetRequest mocks base method. -func (m *MockEC2) ModifyCapacityReservationFleetRequest(arg0 *ec2.ModifyCapacityReservationFleetInput) (*request.Request, *ec2.ModifyCapacityReservationFleetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyCapacityReservationFleetOutput) - return ret0, ret1 -} - -// ModifyCapacityReservationFleetRequest indicates an expected call of ModifyCapacityReservationFleetRequest. -func (mr *MockEC2MockRecorder) ModifyCapacityReservationFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationFleetRequest", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservationFleetRequest), arg0) -} - -// ModifyCapacityReservationFleetWithContext mocks base method. -func (m *MockEC2) ModifyCapacityReservationFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationFleetInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationFleetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyCapacityReservationFleetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyCapacityReservationFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyCapacityReservationFleetWithContext indicates an expected call of ModifyCapacityReservationFleetWithContext. -func (mr *MockEC2MockRecorder) ModifyCapacityReservationFleetWithContext(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, "ModifyCapacityReservationFleetWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservationFleetWithContext), varargs...) -} - -// ModifyCapacityReservationRequest mocks base method. -func (m *MockEC2) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput) - return ret0, ret1 -} - -// ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest. -func (mr *MockEC2MockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservationRequest), arg0) -} - -// ModifyCapacityReservationWithContext mocks base method. -func (m *MockEC2) ModifyCapacityReservationWithContext(arg0 context.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyCapacityReservationWithContext indicates an expected call of ModifyCapacityReservationWithContext. -func (mr *MockEC2MockRecorder) ModifyCapacityReservationWithContext(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, "ModifyCapacityReservationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyCapacityReservationWithContext), varargs...) -} - -// ModifyClientVpnEndpoint mocks base method. -func (m *MockEC2) ModifyClientVpnEndpoint(arg0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyClientVpnEndpoint", arg0) - ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyClientVpnEndpoint indicates an expected call of ModifyClientVpnEndpoint. -func (mr *MockEC2MockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2)(nil).ModifyClientVpnEndpoint), arg0) -} - -// ModifyClientVpnEndpointRequest mocks base method. -func (m *MockEC2) ModifyClientVpnEndpointRequest(arg0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyClientVpnEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyClientVpnEndpointOutput) - return ret0, ret1 -} - -// ModifyClientVpnEndpointRequest indicates an expected call of ModifyClientVpnEndpointRequest. -func (mr *MockEC2MockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2)(nil).ModifyClientVpnEndpointRequest), arg0) -} - -// ModifyClientVpnEndpointWithContext mocks base method. -func (m *MockEC2) ModifyClientVpnEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyClientVpnEndpointInput, arg2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyClientVpnEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyClientVpnEndpointWithContext indicates an expected call of ModifyClientVpnEndpointWithContext. -func (mr *MockEC2MockRecorder) ModifyClientVpnEndpointWithContext(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, "ModifyClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyClientVpnEndpointWithContext), varargs...) -} - -// ModifyDefaultCreditSpecification mocks base method. -func (m *MockEC2) ModifyDefaultCreditSpecification(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*ec2.ModifyDefaultCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecification", arg0) - ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyDefaultCreditSpecification indicates an expected call of ModifyDefaultCreditSpecification. -func (mr *MockEC2MockRecorder) ModifyDefaultCreditSpecification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecification", reflect.TypeOf((*MockEC2)(nil).ModifyDefaultCreditSpecification), arg0) -} - -// ModifyDefaultCreditSpecificationRequest mocks base method. -func (m *MockEC2) ModifyDefaultCreditSpecificationRequest(arg0 *ec2.ModifyDefaultCreditSpecificationInput) (*request.Request, *ec2.ModifyDefaultCreditSpecificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyDefaultCreditSpecificationOutput) - return ret0, ret1 -} - -// ModifyDefaultCreditSpecificationRequest indicates an expected call of ModifyDefaultCreditSpecificationRequest. -func (mr *MockEC2MockRecorder) ModifyDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyDefaultCreditSpecificationRequest), arg0) -} - -// ModifyDefaultCreditSpecificationWithContext mocks base method. -func (m *MockEC2) ModifyDefaultCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyDefaultCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyDefaultCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyDefaultCreditSpecificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyDefaultCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyDefaultCreditSpecificationWithContext indicates an expected call of ModifyDefaultCreditSpecificationWithContext. -func (mr *MockEC2MockRecorder) ModifyDefaultCreditSpecificationWithContext(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, "ModifyDefaultCreditSpecificationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyDefaultCreditSpecificationWithContext), varargs...) -} - -// ModifyEbsDefaultKmsKeyId mocks base method. -func (m *MockEC2) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0) - ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId. -func (mr *MockEC2MockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2)(nil).ModifyEbsDefaultKmsKeyId), arg0) -} - -// ModifyEbsDefaultKmsKeyIdRequest mocks base method. -func (m *MockEC2) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) - return ret0, ret1 -} - -// ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest. -func (mr *MockEC2MockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0) -} - -// ModifyEbsDefaultKmsKeyIdWithContext mocks base method. -func (m *MockEC2) ModifyEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyEbsDefaultKmsKeyIdWithContext indicates an expected call of ModifyEbsDefaultKmsKeyIdWithContext. -func (mr *MockEC2MockRecorder) ModifyEbsDefaultKmsKeyIdWithContext(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, "ModifyEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...) -} - -// ModifyFleet mocks base method. -func (m *MockEC2) ModifyFleet(arg0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyFleet", arg0) - ret0, _ := ret[0].(*ec2.ModifyFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyFleet indicates an expected call of ModifyFleet. -func (mr *MockEC2MockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2)(nil).ModifyFleet), arg0) -} - -// ModifyFleetRequest mocks base method. -func (m *MockEC2) ModifyFleetRequest(arg0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyFleetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyFleetOutput) - return ret0, ret1 -} - -// ModifyFleetRequest indicates an expected call of ModifyFleetRequest. -func (mr *MockEC2MockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2)(nil).ModifyFleetRequest), arg0) -} - -// ModifyFleetWithContext mocks base method. -func (m *MockEC2) ModifyFleetWithContext(arg0 context.Context, arg1 *ec2.ModifyFleetInput, arg2 ...request.Option) (*ec2.ModifyFleetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyFleetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyFleetWithContext indicates an expected call of ModifyFleetWithContext. -func (mr *MockEC2MockRecorder) ModifyFleetWithContext(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, "ModifyFleetWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyFleetWithContext), varargs...) -} - -// ModifyFpgaImageAttribute mocks base method. -func (m *MockEC2) ModifyFpgaImageAttribute(arg0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyFpgaImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyFpgaImageAttribute indicates an expected call of ModifyFpgaImageAttribute. -func (mr *MockEC2MockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyFpgaImageAttribute), arg0) -} - -// ModifyFpgaImageAttributeRequest mocks base method. -func (m *MockEC2) ModifyFpgaImageAttributeRequest(arg0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyFpgaImageAttributeOutput) - return ret0, ret1 -} - -// ModifyFpgaImageAttributeRequest indicates an expected call of ModifyFpgaImageAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyFpgaImageAttributeRequest), arg0) -} - -// ModifyFpgaImageAttributeWithContext mocks base method. -func (m *MockEC2) ModifyFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyFpgaImageAttributeWithContext indicates an expected call of ModifyFpgaImageAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyFpgaImageAttributeWithContext(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, "ModifyFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyFpgaImageAttributeWithContext), varargs...) -} - -// ModifyHosts mocks base method. -func (m *MockEC2) ModifyHosts(arg0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyHosts", arg0) - ret0, _ := ret[0].(*ec2.ModifyHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyHosts indicates an expected call of ModifyHosts. -func (mr *MockEC2MockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2)(nil).ModifyHosts), arg0) -} - -// ModifyHostsRequest mocks base method. -func (m *MockEC2) ModifyHostsRequest(arg0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyHostsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyHostsOutput) - return ret0, ret1 -} - -// ModifyHostsRequest indicates an expected call of ModifyHostsRequest. -func (mr *MockEC2MockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyHostsRequest), arg0) -} - -// ModifyHostsWithContext mocks base method. -func (m *MockEC2) ModifyHostsWithContext(arg0 context.Context, arg1 *ec2.ModifyHostsInput, arg2 ...request.Option) (*ec2.ModifyHostsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyHostsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyHostsWithContext indicates an expected call of ModifyHostsWithContext. -func (mr *MockEC2MockRecorder) ModifyHostsWithContext(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, "ModifyHostsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyHostsWithContext), varargs...) -} - -// ModifyIdFormat mocks base method. -func (m *MockEC2) ModifyIdFormat(arg0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIdFormat", arg0) - ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIdFormat indicates an expected call of ModifyIdFormat. -func (mr *MockEC2MockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2)(nil).ModifyIdFormat), arg0) -} - -// ModifyIdFormatRequest mocks base method. -func (m *MockEC2) ModifyIdFormatRequest(arg0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIdFormatOutput) - return ret0, ret1 -} - -// ModifyIdFormatRequest indicates an expected call of ModifyIdFormatRequest. -func (mr *MockEC2MockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIdFormatRequest), arg0) -} - -// ModifyIdFormatWithContext mocks base method. -func (m *MockEC2) ModifyIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIdFormatWithContext indicates an expected call of ModifyIdFormatWithContext. -func (mr *MockEC2MockRecorder) ModifyIdFormatWithContext(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, "ModifyIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIdFormatWithContext), varargs...) -} - -// ModifyIdentityIdFormat mocks base method. -func (m *MockEC2) ModifyIdentityIdFormat(arg0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIdentityIdFormat", arg0) - ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIdentityIdFormat indicates an expected call of ModifyIdentityIdFormat. -func (mr *MockEC2MockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2)(nil).ModifyIdentityIdFormat), arg0) -} - -// ModifyIdentityIdFormatRequest mocks base method. -func (m *MockEC2) ModifyIdentityIdFormatRequest(arg0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIdentityIdFormatRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIdentityIdFormatOutput) - return ret0, ret1 -} - -// ModifyIdentityIdFormatRequest indicates an expected call of ModifyIdentityIdFormatRequest. -func (mr *MockEC2MockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIdentityIdFormatRequest), arg0) -} - -// ModifyIdentityIdFormatWithContext mocks base method. -func (m *MockEC2) ModifyIdentityIdFormatWithContext(arg0 context.Context, arg1 *ec2.ModifyIdentityIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIdentityIdFormatWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIdentityIdFormatWithContext indicates an expected call of ModifyIdentityIdFormatWithContext. -func (mr *MockEC2MockRecorder) ModifyIdentityIdFormatWithContext(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, "ModifyIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIdentityIdFormatWithContext), varargs...) -} - -// ModifyImageAttribute mocks base method. -func (m *MockEC2) ModifyImageAttribute(arg0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyImageAttribute indicates an expected call of ModifyImageAttribute. -func (mr *MockEC2MockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyImageAttribute), arg0) -} - -// ModifyImageAttributeRequest mocks base method. -func (m *MockEC2) ModifyImageAttributeRequest(arg0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyImageAttributeOutput) - return ret0, ret1 -} - -// ModifyImageAttributeRequest indicates an expected call of ModifyImageAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyImageAttributeRequest), arg0) -} - -// ModifyImageAttributeWithContext mocks base method. -func (m *MockEC2) ModifyImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyImageAttributeWithContext indicates an expected call of ModifyImageAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyImageAttributeWithContext(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, "ModifyImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyImageAttributeWithContext), varargs...) -} - -// ModifyInstanceAttribute mocks base method. -func (m *MockEC2) ModifyInstanceAttribute(arg0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute. -func (mr *MockEC2MockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceAttribute), arg0) -} - -// ModifyInstanceAttributeRequest mocks base method. -func (m *MockEC2) ModifyInstanceAttributeRequest(arg0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceAttributeOutput) - return ret0, ret1 -} - -// ModifyInstanceAttributeRequest indicates an expected call of ModifyInstanceAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceAttributeRequest), arg0) -} - -// ModifyInstanceAttributeWithContext mocks base method. -func (m *MockEC2) ModifyInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceAttributeInput, arg2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceAttributeWithContext indicates an expected call of ModifyInstanceAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceAttributeWithContext(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, "ModifyInstanceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceAttributeWithContext), varargs...) -} - -// ModifyInstanceCapacityReservationAttributes mocks base method. -func (m *MockEC2) ModifyInstanceCapacityReservationAttributes(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributes", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceCapacityReservationAttributes indicates an expected call of ModifyInstanceCapacityReservationAttributes. -func (mr *MockEC2MockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCapacityReservationAttributes), arg0) -} - -// ModifyInstanceCapacityReservationAttributesRequest mocks base method. -func (m *MockEC2) ModifyInstanceCapacityReservationAttributesRequest(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) - return ret0, ret1 -} - -// ModifyInstanceCapacityReservationAttributesRequest indicates an expected call of ModifyInstanceCapacityReservationAttributesRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0) -} - -// ModifyInstanceCapacityReservationAttributesWithContext mocks base method. -func (m *MockEC2) ModifyInstanceCapacityReservationAttributesWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCapacityReservationAttributesInput, arg2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceCapacityReservationAttributesWithContext indicates an expected call of ModifyInstanceCapacityReservationAttributesWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceCapacityReservationAttributesWithContext(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, "ModifyInstanceCapacityReservationAttributesWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCapacityReservationAttributesWithContext), varargs...) -} - -// ModifyInstanceCreditSpecification mocks base method. -func (m *MockEC2) ModifyInstanceCreditSpecification(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecification", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceCreditSpecification indicates an expected call of ModifyInstanceCreditSpecification. -func (mr *MockEC2MockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCreditSpecification), arg0) -} - -// ModifyInstanceCreditSpecificationRequest mocks base method. -func (m *MockEC2) ModifyInstanceCreditSpecificationRequest(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceCreditSpecificationOutput) - return ret0, ret1 -} - -// ModifyInstanceCreditSpecificationRequest indicates an expected call of ModifyInstanceCreditSpecificationRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCreditSpecificationRequest), arg0) -} - -// ModifyInstanceCreditSpecificationWithContext mocks base method. -func (m *MockEC2) ModifyInstanceCreditSpecificationWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceCreditSpecificationWithContext indicates an expected call of ModifyInstanceCreditSpecificationWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceCreditSpecificationWithContext(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, "ModifyInstanceCreditSpecificationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceCreditSpecificationWithContext), varargs...) -} - -// ModifyInstanceEventStartTime mocks base method. -func (m *MockEC2) ModifyInstanceEventStartTime(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceEventStartTime", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceEventStartTime indicates an expected call of ModifyInstanceEventStartTime. -func (mr *MockEC2MockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventStartTime), arg0) -} - -// ModifyInstanceEventStartTimeRequest mocks base method. -func (m *MockEC2) ModifyInstanceEventStartTimeRequest(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceEventStartTimeOutput) - return ret0, ret1 -} - -// ModifyInstanceEventStartTimeRequest indicates an expected call of ModifyInstanceEventStartTimeRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventStartTimeRequest), arg0) -} - -// ModifyInstanceEventStartTimeWithContext mocks base method. -func (m *MockEC2) ModifyInstanceEventStartTimeWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventStartTimeInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceEventStartTimeWithContext indicates an expected call of ModifyInstanceEventStartTimeWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceEventStartTimeWithContext(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, "ModifyInstanceEventStartTimeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventStartTimeWithContext), varargs...) -} - -// ModifyInstanceEventWindow mocks base method. -func (m *MockEC2) ModifyInstanceEventWindow(arg0 *ec2.ModifyInstanceEventWindowInput) (*ec2.ModifyInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceEventWindow", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceEventWindow indicates an expected call of ModifyInstanceEventWindow. -func (mr *MockEC2MockRecorder) ModifyInstanceEventWindow(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindow", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventWindow), arg0) -} - -// ModifyInstanceEventWindowRequest mocks base method. -func (m *MockEC2) ModifyInstanceEventWindowRequest(arg0 *ec2.ModifyInstanceEventWindowInput) (*request.Request, *ec2.ModifyInstanceEventWindowOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceEventWindowRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceEventWindowOutput) - return ret0, ret1 -} - -// ModifyInstanceEventWindowRequest indicates an expected call of ModifyInstanceEventWindowRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceEventWindowRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventWindowRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventWindowRequest), arg0) -} - -// ModifyInstanceEventWindowWithContext mocks base method. -func (m *MockEC2) ModifyInstanceEventWindowWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceEventWindowInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventWindowOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceEventWindowWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceEventWindowOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceEventWindowWithContext indicates an expected call of ModifyInstanceEventWindowWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceEventWindowWithContext(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, "ModifyInstanceEventWindowWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceEventWindowWithContext), varargs...) -} - -// ModifyInstanceMaintenanceOptions mocks base method. -func (m *MockEC2) ModifyInstanceMaintenanceOptions(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceMaintenanceOptions indicates an expected call of ModifyInstanceMaintenanceOptions. -func (mr *MockEC2MockRecorder) ModifyInstanceMaintenanceOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptions", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMaintenanceOptions), arg0) -} - -// ModifyInstanceMaintenanceOptionsRequest mocks base method. -func (m *MockEC2) ModifyInstanceMaintenanceOptionsRequest(arg0 *ec2.ModifyInstanceMaintenanceOptionsInput) (*request.Request, *ec2.ModifyInstanceMaintenanceOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceMaintenanceOptionsOutput) - return ret0, ret1 -} - -// ModifyInstanceMaintenanceOptionsRequest indicates an expected call of ModifyInstanceMaintenanceOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceMaintenanceOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMaintenanceOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMaintenanceOptionsRequest), arg0) -} - -// ModifyInstanceMaintenanceOptionsWithContext mocks base method. -func (m *MockEC2) ModifyInstanceMaintenanceOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMaintenanceOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMaintenanceOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceMaintenanceOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceMaintenanceOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceMaintenanceOptionsWithContext indicates an expected call of ModifyInstanceMaintenanceOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceMaintenanceOptionsWithContext(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, "ModifyInstanceMaintenanceOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMaintenanceOptionsWithContext), varargs...) -} - -// ModifyInstanceMetadataOptions mocks base method. -func (m *MockEC2) ModifyInstanceMetadataOptions(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*ec2.ModifyInstanceMetadataOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceMetadataOptions indicates an expected call of ModifyInstanceMetadataOptions. -func (mr *MockEC2MockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMetadataOptions), arg0) -} - -// ModifyInstanceMetadataOptionsRequest mocks base method. -func (m *MockEC2) ModifyInstanceMetadataOptionsRequest(arg0 *ec2.ModifyInstanceMetadataOptionsInput) (*request.Request, *ec2.ModifyInstanceMetadataOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstanceMetadataOptionsOutput) - return ret0, ret1 -} - -// ModifyInstanceMetadataOptionsRequest indicates an expected call of ModifyInstanceMetadataOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyInstanceMetadataOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMetadataOptionsRequest), arg0) -} - -// ModifyInstanceMetadataOptionsWithContext mocks base method. -func (m *MockEC2) ModifyInstanceMetadataOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyInstanceMetadataOptionsInput, arg2 ...request.Option) (*ec2.ModifyInstanceMetadataOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstanceMetadataOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstanceMetadataOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstanceMetadataOptionsWithContext indicates an expected call of ModifyInstanceMetadataOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyInstanceMetadataOptionsWithContext(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, "ModifyInstanceMetadataOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstanceMetadataOptionsWithContext), varargs...) -} - -// ModifyInstancePlacement mocks base method. -func (m *MockEC2) ModifyInstancePlacement(arg0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstancePlacement", arg0) - ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstancePlacement indicates an expected call of ModifyInstancePlacement. -func (mr *MockEC2MockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2)(nil).ModifyInstancePlacement), arg0) -} - -// ModifyInstancePlacementRequest mocks base method. -func (m *MockEC2) ModifyInstancePlacementRequest(arg0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyInstancePlacementRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyInstancePlacementOutput) - return ret0, ret1 -} - -// ModifyInstancePlacementRequest indicates an expected call of ModifyInstancePlacementRequest. -func (mr *MockEC2MockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2)(nil).ModifyInstancePlacementRequest), arg0) -} - -// ModifyInstancePlacementWithContext mocks base method. -func (m *MockEC2) ModifyInstancePlacementWithContext(arg0 context.Context, arg1 *ec2.ModifyInstancePlacementInput, arg2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyInstancePlacementWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyInstancePlacementWithContext indicates an expected call of ModifyInstancePlacementWithContext. -func (mr *MockEC2MockRecorder) ModifyInstancePlacementWithContext(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, "ModifyInstancePlacementWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyInstancePlacementWithContext), varargs...) -} - -// ModifyIpam mocks base method. -func (m *MockEC2) ModifyIpam(arg0 *ec2.ModifyIpamInput) (*ec2.ModifyIpamOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpam", arg0) - ret0, _ := ret[0].(*ec2.ModifyIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpam indicates an expected call of ModifyIpam. -func (mr *MockEC2MockRecorder) ModifyIpam(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpam", reflect.TypeOf((*MockEC2)(nil).ModifyIpam), arg0) -} - -// ModifyIpamPool mocks base method. -func (m *MockEC2) ModifyIpamPool(arg0 *ec2.ModifyIpamPoolInput) (*ec2.ModifyIpamPoolOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamPool", arg0) - ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamPool indicates an expected call of ModifyIpamPool. -func (mr *MockEC2MockRecorder) ModifyIpamPool(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPool", reflect.TypeOf((*MockEC2)(nil).ModifyIpamPool), arg0) -} - -// ModifyIpamPoolRequest mocks base method. -func (m *MockEC2) ModifyIpamPoolRequest(arg0 *ec2.ModifyIpamPoolInput) (*request.Request, *ec2.ModifyIpamPoolOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamPoolRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIpamPoolOutput) - return ret0, ret1 -} - -// ModifyIpamPoolRequest indicates an expected call of ModifyIpamPoolRequest. -func (mr *MockEC2MockRecorder) ModifyIpamPoolRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamPoolRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIpamPoolRequest), arg0) -} - -// ModifyIpamPoolWithContext mocks base method. -func (m *MockEC2) ModifyIpamPoolWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamPoolInput, arg2 ...request.Option) (*ec2.ModifyIpamPoolOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIpamPoolWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIpamPoolOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamPoolWithContext indicates an expected call of ModifyIpamPoolWithContext. -func (mr *MockEC2MockRecorder) ModifyIpamPoolWithContext(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, "ModifyIpamPoolWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIpamPoolWithContext), varargs...) -} - -// ModifyIpamRequest mocks base method. -func (m *MockEC2) ModifyIpamRequest(arg0 *ec2.ModifyIpamInput) (*request.Request, *ec2.ModifyIpamOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIpamOutput) - return ret0, ret1 -} - -// ModifyIpamRequest indicates an expected call of ModifyIpamRequest. -func (mr *MockEC2MockRecorder) ModifyIpamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIpamRequest), arg0) -} - -// ModifyIpamResourceCidr mocks base method. -func (m *MockEC2) ModifyIpamResourceCidr(arg0 *ec2.ModifyIpamResourceCidrInput) (*ec2.ModifyIpamResourceCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamResourceCidr", arg0) - ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamResourceCidr indicates an expected call of ModifyIpamResourceCidr. -func (mr *MockEC2MockRecorder) ModifyIpamResourceCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidr", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceCidr), arg0) -} - -// ModifyIpamResourceCidrRequest mocks base method. -func (m *MockEC2) ModifyIpamResourceCidrRequest(arg0 *ec2.ModifyIpamResourceCidrInput) (*request.Request, *ec2.ModifyIpamResourceCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamResourceCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIpamResourceCidrOutput) - return ret0, ret1 -} - -// ModifyIpamResourceCidrRequest indicates an expected call of ModifyIpamResourceCidrRequest. -func (mr *MockEC2MockRecorder) ModifyIpamResourceCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceCidrRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceCidrRequest), arg0) -} - -// ModifyIpamResourceCidrWithContext mocks base method. -func (m *MockEC2) ModifyIpamResourceCidrWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceCidrInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIpamResourceCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIpamResourceCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamResourceCidrWithContext indicates an expected call of ModifyIpamResourceCidrWithContext. -func (mr *MockEC2MockRecorder) ModifyIpamResourceCidrWithContext(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, "ModifyIpamResourceCidrWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceCidrWithContext), varargs...) -} - -// ModifyIpamResourceDiscovery mocks base method. -func (m *MockEC2) ModifyIpamResourceDiscovery(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*ec2.ModifyIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamResourceDiscovery", arg0) - ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamResourceDiscovery indicates an expected call of ModifyIpamResourceDiscovery. -func (mr *MockEC2MockRecorder) ModifyIpamResourceDiscovery(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscovery", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceDiscovery), arg0) -} - -// ModifyIpamResourceDiscoveryRequest mocks base method. -func (m *MockEC2) ModifyIpamResourceDiscoveryRequest(arg0 *ec2.ModifyIpamResourceDiscoveryInput) (*request.Request, *ec2.ModifyIpamResourceDiscoveryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIpamResourceDiscoveryOutput) - return ret0, ret1 -} - -// ModifyIpamResourceDiscoveryRequest indicates an expected call of ModifyIpamResourceDiscoveryRequest. -func (mr *MockEC2MockRecorder) ModifyIpamResourceDiscoveryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamResourceDiscoveryRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceDiscoveryRequest), arg0) -} - -// ModifyIpamResourceDiscoveryWithContext mocks base method. -func (m *MockEC2) ModifyIpamResourceDiscoveryWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamResourceDiscoveryInput, arg2 ...request.Option) (*ec2.ModifyIpamResourceDiscoveryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIpamResourceDiscoveryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIpamResourceDiscoveryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamResourceDiscoveryWithContext indicates an expected call of ModifyIpamResourceDiscoveryWithContext. -func (mr *MockEC2MockRecorder) ModifyIpamResourceDiscoveryWithContext(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, "ModifyIpamResourceDiscoveryWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIpamResourceDiscoveryWithContext), varargs...) -} - -// ModifyIpamScope mocks base method. -func (m *MockEC2) ModifyIpamScope(arg0 *ec2.ModifyIpamScopeInput) (*ec2.ModifyIpamScopeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamScope", arg0) - ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamScope indicates an expected call of ModifyIpamScope. -func (mr *MockEC2MockRecorder) ModifyIpamScope(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScope", reflect.TypeOf((*MockEC2)(nil).ModifyIpamScope), arg0) -} - -// ModifyIpamScopeRequest mocks base method. -func (m *MockEC2) ModifyIpamScopeRequest(arg0 *ec2.ModifyIpamScopeInput) (*request.Request, *ec2.ModifyIpamScopeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyIpamScopeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyIpamScopeOutput) - return ret0, ret1 -} - -// ModifyIpamScopeRequest indicates an expected call of ModifyIpamScopeRequest. -func (mr *MockEC2MockRecorder) ModifyIpamScopeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIpamScopeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyIpamScopeRequest), arg0) -} - -// ModifyIpamScopeWithContext mocks base method. -func (m *MockEC2) ModifyIpamScopeWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamScopeInput, arg2 ...request.Option) (*ec2.ModifyIpamScopeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIpamScopeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIpamScopeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamScopeWithContext indicates an expected call of ModifyIpamScopeWithContext. -func (mr *MockEC2MockRecorder) ModifyIpamScopeWithContext(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, "ModifyIpamScopeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIpamScopeWithContext), varargs...) -} - -// ModifyIpamWithContext mocks base method. -func (m *MockEC2) ModifyIpamWithContext(arg0 context.Context, arg1 *ec2.ModifyIpamInput, arg2 ...request.Option) (*ec2.ModifyIpamOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyIpamWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyIpamWithContext indicates an expected call of ModifyIpamWithContext. -func (mr *MockEC2MockRecorder) ModifyIpamWithContext(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, "ModifyIpamWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyIpamWithContext), varargs...) -} - -// ModifyLaunchTemplate mocks base method. -func (m *MockEC2) ModifyLaunchTemplate(arg0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLaunchTemplate", arg0) - ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLaunchTemplate indicates an expected call of ModifyLaunchTemplate. -func (mr *MockEC2MockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2)(nil).ModifyLaunchTemplate), arg0) -} - -// ModifyLaunchTemplateRequest mocks base method. -func (m *MockEC2) ModifyLaunchTemplateRequest(arg0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLaunchTemplateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyLaunchTemplateOutput) - return ret0, ret1 -} - -// ModifyLaunchTemplateRequest indicates an expected call of ModifyLaunchTemplateRequest. -func (mr *MockEC2MockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2)(nil).ModifyLaunchTemplateRequest), arg0) -} - -// ModifyLaunchTemplateWithContext mocks base method. -func (m *MockEC2) ModifyLaunchTemplateWithContext(arg0 context.Context, arg1 *ec2.ModifyLaunchTemplateInput, arg2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyLaunchTemplateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLaunchTemplateWithContext indicates an expected call of ModifyLaunchTemplateWithContext. -func (mr *MockEC2MockRecorder) ModifyLaunchTemplateWithContext(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, "ModifyLaunchTemplateWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyLaunchTemplateWithContext), varargs...) -} - -// ModifyLocalGatewayRoute mocks base method. -func (m *MockEC2) ModifyLocalGatewayRoute(arg0 *ec2.ModifyLocalGatewayRouteInput) (*ec2.ModifyLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLocalGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLocalGatewayRoute indicates an expected call of ModifyLocalGatewayRoute. -func (mr *MockEC2MockRecorder) ModifyLocalGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRoute", reflect.TypeOf((*MockEC2)(nil).ModifyLocalGatewayRoute), arg0) -} - -// ModifyLocalGatewayRouteRequest mocks base method. -func (m *MockEC2) ModifyLocalGatewayRouteRequest(arg0 *ec2.ModifyLocalGatewayRouteInput) (*request.Request, *ec2.ModifyLocalGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyLocalGatewayRouteOutput) - return ret0, ret1 -} - -// ModifyLocalGatewayRouteRequest indicates an expected call of ModifyLocalGatewayRouteRequest. -func (mr *MockEC2MockRecorder) ModifyLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).ModifyLocalGatewayRouteRequest), arg0) -} - -// ModifyLocalGatewayRouteWithContext mocks base method. -func (m *MockEC2) ModifyLocalGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ModifyLocalGatewayRouteInput, arg2 ...request.Option) (*ec2.ModifyLocalGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyLocalGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyLocalGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLocalGatewayRouteWithContext indicates an expected call of ModifyLocalGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) ModifyLocalGatewayRouteWithContext(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, "ModifyLocalGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyLocalGatewayRouteWithContext), varargs...) -} - -// ModifyManagedPrefixList mocks base method. -func (m *MockEC2) ModifyManagedPrefixList(arg0 *ec2.ModifyManagedPrefixListInput) (*ec2.ModifyManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyManagedPrefixList", arg0) - ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyManagedPrefixList indicates an expected call of ModifyManagedPrefixList. -func (mr *MockEC2MockRecorder) ModifyManagedPrefixList(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixList", reflect.TypeOf((*MockEC2)(nil).ModifyManagedPrefixList), arg0) -} - -// ModifyManagedPrefixListRequest mocks base method. -func (m *MockEC2) ModifyManagedPrefixListRequest(arg0 *ec2.ModifyManagedPrefixListInput) (*request.Request, *ec2.ModifyManagedPrefixListOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyManagedPrefixListRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyManagedPrefixListOutput) - return ret0, ret1 -} - -// ModifyManagedPrefixListRequest indicates an expected call of ModifyManagedPrefixListRequest. -func (mr *MockEC2MockRecorder) ModifyManagedPrefixListRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyManagedPrefixListRequest", reflect.TypeOf((*MockEC2)(nil).ModifyManagedPrefixListRequest), arg0) -} - -// ModifyManagedPrefixListWithContext mocks base method. -func (m *MockEC2) ModifyManagedPrefixListWithContext(arg0 context.Context, arg1 *ec2.ModifyManagedPrefixListInput, arg2 ...request.Option) (*ec2.ModifyManagedPrefixListOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyManagedPrefixListWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyManagedPrefixListOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyManagedPrefixListWithContext indicates an expected call of ModifyManagedPrefixListWithContext. -func (mr *MockEC2MockRecorder) ModifyManagedPrefixListWithContext(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, "ModifyManagedPrefixListWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyManagedPrefixListWithContext), varargs...) -} - -// ModifyNetworkInterfaceAttribute mocks base method. -func (m *MockEC2) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute. -func (mr *MockEC2MockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyNetworkInterfaceAttribute), arg0) -} - -// ModifyNetworkInterfaceAttributeRequest mocks base method. -func (m *MockEC2) ModifyNetworkInterfaceAttributeRequest(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyNetworkInterfaceAttributeOutput) - return ret0, ret1 -} - -// ModifyNetworkInterfaceAttributeRequest indicates an expected call of ModifyNetworkInterfaceAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyNetworkInterfaceAttributeRequest), arg0) -} - -// ModifyNetworkInterfaceAttributeWithContext mocks base method. -func (m *MockEC2) ModifyNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyNetworkInterfaceAttributeWithContext indicates an expected call of ModifyNetworkInterfaceAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyNetworkInterfaceAttributeWithContext(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, "ModifyNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyNetworkInterfaceAttributeWithContext), varargs...) -} - -// ModifyPrivateDnsNameOptions mocks base method. -func (m *MockEC2) ModifyPrivateDnsNameOptions(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyPrivateDnsNameOptions indicates an expected call of ModifyPrivateDnsNameOptions. -func (mr *MockEC2MockRecorder) ModifyPrivateDnsNameOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptions", reflect.TypeOf((*MockEC2)(nil).ModifyPrivateDnsNameOptions), arg0) -} - -// ModifyPrivateDnsNameOptionsRequest mocks base method. -func (m *MockEC2) ModifyPrivateDnsNameOptionsRequest(arg0 *ec2.ModifyPrivateDnsNameOptionsInput) (*request.Request, *ec2.ModifyPrivateDnsNameOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyPrivateDnsNameOptionsOutput) - return ret0, ret1 -} - -// ModifyPrivateDnsNameOptionsRequest indicates an expected call of ModifyPrivateDnsNameOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyPrivateDnsNameOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyPrivateDnsNameOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyPrivateDnsNameOptionsRequest), arg0) -} - -// ModifyPrivateDnsNameOptionsWithContext mocks base method. -func (m *MockEC2) ModifyPrivateDnsNameOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyPrivateDnsNameOptionsInput, arg2 ...request.Option) (*ec2.ModifyPrivateDnsNameOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyPrivateDnsNameOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyPrivateDnsNameOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyPrivateDnsNameOptionsWithContext indicates an expected call of ModifyPrivateDnsNameOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyPrivateDnsNameOptionsWithContext(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, "ModifyPrivateDnsNameOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyPrivateDnsNameOptionsWithContext), varargs...) -} - -// ModifyReservedInstances mocks base method. -func (m *MockEC2) ModifyReservedInstances(arg0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyReservedInstances", arg0) - ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyReservedInstances indicates an expected call of ModifyReservedInstances. -func (mr *MockEC2MockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2)(nil).ModifyReservedInstances), arg0) -} - -// ModifyReservedInstancesRequest mocks base method. -func (m *MockEC2) ModifyReservedInstancesRequest(arg0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyReservedInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyReservedInstancesOutput) - return ret0, ret1 -} - -// ModifyReservedInstancesRequest indicates an expected call of ModifyReservedInstancesRequest. -func (mr *MockEC2MockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2)(nil).ModifyReservedInstancesRequest), arg0) -} - -// ModifyReservedInstancesWithContext mocks base method. -func (m *MockEC2) ModifyReservedInstancesWithContext(arg0 context.Context, arg1 *ec2.ModifyReservedInstancesInput, arg2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyReservedInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyReservedInstancesWithContext indicates an expected call of ModifyReservedInstancesWithContext. -func (mr *MockEC2MockRecorder) ModifyReservedInstancesWithContext(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, "ModifyReservedInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyReservedInstancesWithContext), varargs...) -} - -// ModifySecurityGroupRules mocks base method. -func (m *MockEC2) ModifySecurityGroupRules(arg0 *ec2.ModifySecurityGroupRulesInput) (*ec2.ModifySecurityGroupRulesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySecurityGroupRules", arg0) - ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySecurityGroupRules indicates an expected call of ModifySecurityGroupRules. -func (mr *MockEC2MockRecorder) ModifySecurityGroupRules(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRules", reflect.TypeOf((*MockEC2)(nil).ModifySecurityGroupRules), arg0) -} - -// ModifySecurityGroupRulesRequest mocks base method. -func (m *MockEC2) ModifySecurityGroupRulesRequest(arg0 *ec2.ModifySecurityGroupRulesInput) (*request.Request, *ec2.ModifySecurityGroupRulesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySecurityGroupRulesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifySecurityGroupRulesOutput) - return ret0, ret1 -} - -// ModifySecurityGroupRulesRequest indicates an expected call of ModifySecurityGroupRulesRequest. -func (mr *MockEC2MockRecorder) ModifySecurityGroupRulesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySecurityGroupRulesRequest", reflect.TypeOf((*MockEC2)(nil).ModifySecurityGroupRulesRequest), arg0) -} - -// ModifySecurityGroupRulesWithContext mocks base method. -func (m *MockEC2) ModifySecurityGroupRulesWithContext(arg0 context.Context, arg1 *ec2.ModifySecurityGroupRulesInput, arg2 ...request.Option) (*ec2.ModifySecurityGroupRulesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifySecurityGroupRulesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifySecurityGroupRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySecurityGroupRulesWithContext indicates an expected call of ModifySecurityGroupRulesWithContext. -func (mr *MockEC2MockRecorder) ModifySecurityGroupRulesWithContext(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, "ModifySecurityGroupRulesWithContext", reflect.TypeOf((*MockEC2)(nil).ModifySecurityGroupRulesWithContext), varargs...) -} - -// ModifySnapshotAttribute mocks base method. -func (m *MockEC2) ModifySnapshotAttribute(arg0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySnapshotAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySnapshotAttribute indicates an expected call of ModifySnapshotAttribute. -func (mr *MockEC2MockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotAttribute), arg0) -} - -// ModifySnapshotAttributeRequest mocks base method. -func (m *MockEC2) ModifySnapshotAttributeRequest(arg0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySnapshotAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifySnapshotAttributeOutput) - return ret0, ret1 -} - -// ModifySnapshotAttributeRequest indicates an expected call of ModifySnapshotAttributeRequest. -func (mr *MockEC2MockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotAttributeRequest), arg0) -} - -// ModifySnapshotAttributeWithContext mocks base method. -func (m *MockEC2) ModifySnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotAttributeInput, arg2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifySnapshotAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySnapshotAttributeWithContext indicates an expected call of ModifySnapshotAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifySnapshotAttributeWithContext(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, "ModifySnapshotAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotAttributeWithContext), varargs...) -} - -// ModifySnapshotTier mocks base method. -func (m *MockEC2) ModifySnapshotTier(arg0 *ec2.ModifySnapshotTierInput) (*ec2.ModifySnapshotTierOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySnapshotTier", arg0) - ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySnapshotTier indicates an expected call of ModifySnapshotTier. -func (mr *MockEC2MockRecorder) ModifySnapshotTier(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTier", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotTier), arg0) -} - -// ModifySnapshotTierRequest mocks base method. -func (m *MockEC2) ModifySnapshotTierRequest(arg0 *ec2.ModifySnapshotTierInput) (*request.Request, *ec2.ModifySnapshotTierOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySnapshotTierRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifySnapshotTierOutput) - return ret0, ret1 -} - -// ModifySnapshotTierRequest indicates an expected call of ModifySnapshotTierRequest. -func (mr *MockEC2MockRecorder) ModifySnapshotTierRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotTierRequest", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotTierRequest), arg0) -} - -// ModifySnapshotTierWithContext mocks base method. -func (m *MockEC2) ModifySnapshotTierWithContext(arg0 context.Context, arg1 *ec2.ModifySnapshotTierInput, arg2 ...request.Option) (*ec2.ModifySnapshotTierOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifySnapshotTierWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifySnapshotTierOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySnapshotTierWithContext indicates an expected call of ModifySnapshotTierWithContext. -func (mr *MockEC2MockRecorder) ModifySnapshotTierWithContext(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, "ModifySnapshotTierWithContext", reflect.TypeOf((*MockEC2)(nil).ModifySnapshotTierWithContext), varargs...) -} - -// ModifySpotFleetRequest mocks base method. -func (m *MockEC2) ModifySpotFleetRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySpotFleetRequest", arg0) - ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySpotFleetRequest indicates an expected call of ModifySpotFleetRequest. -func (mr *MockEC2MockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2)(nil).ModifySpotFleetRequest), arg0) -} - -// ModifySpotFleetRequestRequest mocks base method. -func (m *MockEC2) ModifySpotFleetRequestRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySpotFleetRequestRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifySpotFleetRequestOutput) - return ret0, ret1 -} - -// ModifySpotFleetRequestRequest indicates an expected call of ModifySpotFleetRequestRequest. -func (mr *MockEC2MockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2)(nil).ModifySpotFleetRequestRequest), arg0) -} - -// ModifySpotFleetRequestWithContext mocks base method. -func (m *MockEC2) ModifySpotFleetRequestWithContext(arg0 context.Context, arg1 *ec2.ModifySpotFleetRequestInput, arg2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifySpotFleetRequestWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySpotFleetRequestWithContext indicates an expected call of ModifySpotFleetRequestWithContext. -func (mr *MockEC2MockRecorder) ModifySpotFleetRequestWithContext(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, "ModifySpotFleetRequestWithContext", reflect.TypeOf((*MockEC2)(nil).ModifySpotFleetRequestWithContext), varargs...) -} - -// ModifySubnetAttribute mocks base method. -func (m *MockEC2) ModifySubnetAttribute(arg0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySubnetAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute. -func (mr *MockEC2MockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2)(nil).ModifySubnetAttribute), arg0) -} - -// ModifySubnetAttributeRequest mocks base method. -func (m *MockEC2) ModifySubnetAttributeRequest(arg0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifySubnetAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifySubnetAttributeOutput) - return ret0, ret1 -} - -// ModifySubnetAttributeRequest indicates an expected call of ModifySubnetAttributeRequest. -func (mr *MockEC2MockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifySubnetAttributeRequest), arg0) -} - -// ModifySubnetAttributeWithContext mocks base method. -func (m *MockEC2) ModifySubnetAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifySubnetAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifySubnetAttributeWithContext indicates an expected call of ModifySubnetAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifySubnetAttributeWithContext(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, "ModifySubnetAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifySubnetAttributeWithContext), varargs...) -} - -// ModifyTrafficMirrorFilterNetworkServices mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterNetworkServices(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServices", arg0) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterNetworkServices indicates an expected call of ModifyTrafficMirrorFilterNetworkServices. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0) -} - -// ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterNetworkServicesRequest indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesRequest. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0) -} - -// ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterNetworkServicesWithContext indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesWithContext. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterNetworkServicesWithContext(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, "ModifyTrafficMirrorFilterNetworkServicesWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterNetworkServicesWithContext), varargs...) -} - -// ModifyTrafficMirrorFilterRule mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterRule(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRule", arg0) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterRule indicates an expected call of ModifyTrafficMirrorFilterRule. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterRule), arg0) -} - -// ModifyTrafficMirrorFilterRuleRequest mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterRuleRequest(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterRuleOutput) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterRuleRequest indicates an expected call of ModifyTrafficMirrorFilterRuleRequest. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0) -} - -// ModifyTrafficMirrorFilterRuleWithContext mocks base method. -func (m *MockEC2) ModifyTrafficMirrorFilterRuleWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorFilterRuleWithContext indicates an expected call of ModifyTrafficMirrorFilterRuleWithContext. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorFilterRuleWithContext(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, "ModifyTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorFilterRuleWithContext), varargs...) -} - -// ModifyTrafficMirrorSession mocks base method. -func (m *MockEC2) ModifyTrafficMirrorSession(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorSession", arg0) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorSession indicates an expected call of ModifyTrafficMirrorSession. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorSession), arg0) -} - -// ModifyTrafficMirrorSessionRequest mocks base method. -func (m *MockEC2) ModifyTrafficMirrorSessionRequest(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorSessionOutput) - return ret0, ret1 -} - -// ModifyTrafficMirrorSessionRequest indicates an expected call of ModifyTrafficMirrorSessionRequest. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorSessionRequest), arg0) -} - -// ModifyTrafficMirrorSessionWithContext mocks base method. -func (m *MockEC2) ModifyTrafficMirrorSessionWithContext(arg0 context.Context, arg1 *ec2.ModifyTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrafficMirrorSessionWithContext indicates an expected call of ModifyTrafficMirrorSessionWithContext. -func (mr *MockEC2MockRecorder) ModifyTrafficMirrorSessionWithContext(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, "ModifyTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTrafficMirrorSessionWithContext), varargs...) -} - -// ModifyTransitGateway mocks base method. -func (m *MockEC2) ModifyTransitGateway(arg0 *ec2.ModifyTransitGatewayInput) (*ec2.ModifyTransitGatewayOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGateway", arg0) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGateway indicates an expected call of ModifyTransitGateway. -func (mr *MockEC2MockRecorder) ModifyTransitGateway(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGateway", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGateway), arg0) -} - -// ModifyTransitGatewayPrefixListReference mocks base method. -func (m *MockEC2) ModifyTransitGatewayPrefixListReference(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReference", arg0) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGatewayPrefixListReference indicates an expected call of ModifyTransitGatewayPrefixListReference. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayPrefixListReference(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReference", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayPrefixListReference), arg0) -} - -// ModifyTransitGatewayPrefixListReferenceRequest mocks base method. -func (m *MockEC2) ModifyTransitGatewayPrefixListReferenceRequest(arg0 *ec2.ModifyTransitGatewayPrefixListReferenceInput) (*request.Request, *ec2.ModifyTransitGatewayPrefixListReferenceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) - return ret0, ret1 -} - -// ModifyTransitGatewayPrefixListReferenceRequest indicates an expected call of ModifyTransitGatewayPrefixListReferenceRequest. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayPrefixListReferenceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayPrefixListReferenceRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayPrefixListReferenceRequest), arg0) -} - -// ModifyTransitGatewayPrefixListReferenceWithContext mocks base method. -func (m *MockEC2) ModifyTransitGatewayPrefixListReferenceWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayPrefixListReferenceInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayPrefixListReferenceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTransitGatewayPrefixListReferenceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayPrefixListReferenceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGatewayPrefixListReferenceWithContext indicates an expected call of ModifyTransitGatewayPrefixListReferenceWithContext. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayPrefixListReferenceWithContext(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, "ModifyTransitGatewayPrefixListReferenceWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayPrefixListReferenceWithContext), varargs...) -} - -// ModifyTransitGatewayRequest mocks base method. -func (m *MockEC2) ModifyTransitGatewayRequest(arg0 *ec2.ModifyTransitGatewayInput) (*request.Request, *ec2.ModifyTransitGatewayOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGatewayRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTransitGatewayOutput) - return ret0, ret1 -} - -// ModifyTransitGatewayRequest indicates an expected call of ModifyTransitGatewayRequest. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayRequest), arg0) -} - -// ModifyTransitGatewayVpcAttachment mocks base method. -func (m *MockEC2) ModifyTransitGatewayVpcAttachment(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachment", arg0) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGatewayVpcAttachment indicates an expected call of ModifyTransitGatewayVpcAttachment. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayVpcAttachment), arg0) -} - -// ModifyTransitGatewayVpcAttachmentRequest mocks base method. -func (m *MockEC2) ModifyTransitGatewayVpcAttachmentRequest(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) - return ret0, ret1 -} - -// ModifyTransitGatewayVpcAttachmentRequest indicates an expected call of ModifyTransitGatewayVpcAttachmentRequest. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0) -} - -// ModifyTransitGatewayVpcAttachmentWithContext mocks base method. -func (m *MockEC2) ModifyTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGatewayVpcAttachmentWithContext indicates an expected call of ModifyTransitGatewayVpcAttachmentWithContext. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayVpcAttachmentWithContext(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, "ModifyTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayVpcAttachmentWithContext), varargs...) -} - -// ModifyTransitGatewayWithContext mocks base method. -func (m *MockEC2) ModifyTransitGatewayWithContext(arg0 context.Context, arg1 *ec2.ModifyTransitGatewayInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTransitGatewayWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyTransitGatewayOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTransitGatewayWithContext indicates an expected call of ModifyTransitGatewayWithContext. -func (mr *MockEC2MockRecorder) ModifyTransitGatewayWithContext(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, "ModifyTransitGatewayWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyTransitGatewayWithContext), varargs...) -} - -// ModifyVerifiedAccessEndpoint mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpoint(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*ec2.ModifyVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpoint", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpoint indicates an expected call of ModifyVerifiedAccessEndpoint. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpoint", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpoint), arg0) -} - -// ModifyVerifiedAccessEndpointPolicy mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpointPolicy(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicy", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpointPolicy indicates an expected call of ModifyVerifiedAccessEndpointPolicy. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpointPolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicy", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpointPolicy), arg0) -} - -// ModifyVerifiedAccessEndpointPolicyRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpointPolicyRequest(arg0 *ec2.ModifyVerifiedAccessEndpointPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointPolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpointPolicyRequest indicates an expected call of ModifyVerifiedAccessEndpointPolicyRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpointPolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointPolicyRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpointPolicyRequest), arg0) -} - -// ModifyVerifiedAccessEndpointPolicyWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpointPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointPolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointPolicyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpointPolicyWithContext indicates an expected call of ModifyVerifiedAccessEndpointPolicyWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpointPolicyWithContext(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, "ModifyVerifiedAccessEndpointPolicyWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpointPolicyWithContext), varargs...) -} - -// ModifyVerifiedAccessEndpointRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpointRequest(arg0 *ec2.ModifyVerifiedAccessEndpointInput) (*request.Request, *ec2.ModifyVerifiedAccessEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessEndpointOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpointRequest indicates an expected call of ModifyVerifiedAccessEndpointRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessEndpointRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpointRequest), arg0) -} - -// ModifyVerifiedAccessEndpointWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessEndpointInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessEndpointWithContext indicates an expected call of ModifyVerifiedAccessEndpointWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessEndpointWithContext(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, "ModifyVerifiedAccessEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessEndpointWithContext), varargs...) -} - -// ModifyVerifiedAccessGroup mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroup(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*ec2.ModifyVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroup", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroup indicates an expected call of ModifyVerifiedAccessGroup. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroup", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroup), arg0) -} - -// ModifyVerifiedAccessGroupPolicy mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroupPolicy(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicy", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroupPolicy indicates an expected call of ModifyVerifiedAccessGroupPolicy. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroupPolicy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicy", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroupPolicy), arg0) -} - -// ModifyVerifiedAccessGroupPolicyRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroupPolicyRequest(arg0 *ec2.ModifyVerifiedAccessGroupPolicyInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupPolicyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupPolicyOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroupPolicyRequest indicates an expected call of ModifyVerifiedAccessGroupPolicyRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroupPolicyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupPolicyRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroupPolicyRequest), arg0) -} - -// ModifyVerifiedAccessGroupPolicyWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroupPolicyWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupPolicyInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupPolicyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupPolicyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupPolicyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroupPolicyWithContext indicates an expected call of ModifyVerifiedAccessGroupPolicyWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroupPolicyWithContext(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, "ModifyVerifiedAccessGroupPolicyWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroupPolicyWithContext), varargs...) -} - -// ModifyVerifiedAccessGroupRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroupRequest(arg0 *ec2.ModifyVerifiedAccessGroupInput) (*request.Request, *ec2.ModifyVerifiedAccessGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessGroupOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroupRequest indicates an expected call of ModifyVerifiedAccessGroupRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessGroupRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroupRequest), arg0) -} - -// ModifyVerifiedAccessGroupWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessGroupWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessGroupInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessGroupWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessGroupWithContext indicates an expected call of ModifyVerifiedAccessGroupWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessGroupWithContext(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, "ModifyVerifiedAccessGroupWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessGroupWithContext), varargs...) -} - -// ModifyVerifiedAccessInstance mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstance(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*ec2.ModifyVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstance", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstance indicates an expected call of ModifyVerifiedAccessInstance. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstance(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstance", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstance), arg0) -} - -// ModifyVerifiedAccessInstanceLoggingConfiguration mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfiguration", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstanceLoggingConfiguration indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfiguration. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstanceLoggingConfiguration(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfiguration", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstanceLoggingConfiguration), arg0) -} - -// ModifyVerifiedAccessInstanceLoggingConfigurationRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstanceLoggingConfigurationRequest indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfigurationRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstanceLoggingConfigurationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceLoggingConfigurationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstanceLoggingConfigurationRequest), arg0) -} - -// ModifyVerifiedAccessInstanceLoggingConfigurationWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstanceLoggingConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceLoggingConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceLoggingConfigurationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceLoggingConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstanceLoggingConfigurationWithContext indicates an expected call of ModifyVerifiedAccessInstanceLoggingConfigurationWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstanceLoggingConfigurationWithContext(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, "ModifyVerifiedAccessInstanceLoggingConfigurationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstanceLoggingConfigurationWithContext), varargs...) -} - -// ModifyVerifiedAccessInstanceRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstanceRequest(arg0 *ec2.ModifyVerifiedAccessInstanceInput) (*request.Request, *ec2.ModifyVerifiedAccessInstanceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessInstanceOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstanceRequest indicates an expected call of ModifyVerifiedAccessInstanceRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstanceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessInstanceRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstanceRequest), arg0) -} - -// ModifyVerifiedAccessInstanceWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessInstanceWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessInstanceInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessInstanceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessInstanceWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessInstanceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessInstanceWithContext indicates an expected call of ModifyVerifiedAccessInstanceWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessInstanceWithContext(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, "ModifyVerifiedAccessInstanceWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessInstanceWithContext), varargs...) -} - -// ModifyVerifiedAccessTrustProvider mocks base method. -func (m *MockEC2) ModifyVerifiedAccessTrustProvider(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProvider", arg0) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessTrustProvider indicates an expected call of ModifyVerifiedAccessTrustProvider. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessTrustProvider(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProvider", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessTrustProvider), arg0) -} - -// ModifyVerifiedAccessTrustProviderRequest mocks base method. -func (m *MockEC2) ModifyVerifiedAccessTrustProviderRequest(arg0 *ec2.ModifyVerifiedAccessTrustProviderInput) (*request.Request, *ec2.ModifyVerifiedAccessTrustProviderOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVerifiedAccessTrustProviderOutput) - return ret0, ret1 -} - -// ModifyVerifiedAccessTrustProviderRequest indicates an expected call of ModifyVerifiedAccessTrustProviderRequest. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessTrustProviderRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVerifiedAccessTrustProviderRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessTrustProviderRequest), arg0) -} - -// ModifyVerifiedAccessTrustProviderWithContext mocks base method. -func (m *MockEC2) ModifyVerifiedAccessTrustProviderWithContext(arg0 context.Context, arg1 *ec2.ModifyVerifiedAccessTrustProviderInput, arg2 ...request.Option) (*ec2.ModifyVerifiedAccessTrustProviderOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVerifiedAccessTrustProviderWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVerifiedAccessTrustProviderOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVerifiedAccessTrustProviderWithContext indicates an expected call of ModifyVerifiedAccessTrustProviderWithContext. -func (mr *MockEC2MockRecorder) ModifyVerifiedAccessTrustProviderWithContext(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, "ModifyVerifiedAccessTrustProviderWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVerifiedAccessTrustProviderWithContext), varargs...) -} - -// ModifyVolume mocks base method. -func (m *MockEC2) ModifyVolume(arg0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVolume", arg0) - ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVolume indicates an expected call of ModifyVolume. -func (mr *MockEC2MockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2)(nil).ModifyVolume), arg0) -} - -// ModifyVolumeAttribute mocks base method. -func (m *MockEC2) ModifyVolumeAttribute(arg0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVolumeAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVolumeAttribute indicates an expected call of ModifyVolumeAttribute. -func (mr *MockEC2MockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeAttribute), arg0) -} - -// ModifyVolumeAttributeRequest mocks base method. -func (m *MockEC2) ModifyVolumeAttributeRequest(arg0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVolumeAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVolumeAttributeOutput) - return ret0, ret1 -} - -// ModifyVolumeAttributeRequest indicates an expected call of ModifyVolumeAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeAttributeRequest), arg0) -} - -// ModifyVolumeAttributeWithContext mocks base method. -func (m *MockEC2) ModifyVolumeAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeAttributeInput, arg2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVolumeAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVolumeAttributeWithContext indicates an expected call of ModifyVolumeAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyVolumeAttributeWithContext(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, "ModifyVolumeAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeAttributeWithContext), varargs...) -} - -// ModifyVolumeRequest mocks base method. -func (m *MockEC2) ModifyVolumeRequest(arg0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVolumeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVolumeOutput) - return ret0, ret1 -} - -// ModifyVolumeRequest indicates an expected call of ModifyVolumeRequest. -func (mr *MockEC2MockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeRequest), arg0) -} - -// ModifyVolumeWithContext mocks base method. -func (m *MockEC2) ModifyVolumeWithContext(arg0 context.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVolumeWithContext indicates an expected call of ModifyVolumeWithContext. -func (mr *MockEC2MockRecorder) ModifyVolumeWithContext(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, "ModifyVolumeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVolumeWithContext), varargs...) -} - -// ModifyVpcAttribute mocks base method. -func (m *MockEC2) ModifyVpcAttribute(arg0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcAttribute", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute. -func (mr *MockEC2MockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2)(nil).ModifyVpcAttribute), arg0) -} - -// ModifyVpcAttributeRequest mocks base method. -func (m *MockEC2) ModifyVpcAttributeRequest(arg0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcAttributeOutput) - return ret0, ret1 -} - -// ModifyVpcAttributeRequest indicates an expected call of ModifyVpcAttributeRequest. -func (mr *MockEC2MockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcAttributeRequest), arg0) -} - -// ModifyVpcAttributeWithContext mocks base method. -func (m *MockEC2) ModifyVpcAttributeWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcAttributeWithContext indicates an expected call of ModifyVpcAttributeWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcAttributeWithContext(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, "ModifyVpcAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcAttributeWithContext), varargs...) -} - -// ModifyVpcEndpoint mocks base method. -func (m *MockEC2) ModifyVpcEndpoint(arg0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpoint", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint. -func (mr *MockEC2MockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpoint), arg0) -} - -// ModifyVpcEndpointConnectionNotification mocks base method. -func (m *MockEC2) ModifyVpcEndpointConnectionNotification(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotification", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointConnectionNotification indicates an expected call of ModifyVpcEndpointConnectionNotification. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointConnectionNotification), arg0) -} - -// ModifyVpcEndpointConnectionNotificationRequest mocks base method. -func (m *MockEC2) ModifyVpcEndpointConnectionNotificationRequest(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) - return ret0, ret1 -} - -// ModifyVpcEndpointConnectionNotificationRequest indicates an expected call of ModifyVpcEndpointConnectionNotificationRequest. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0) -} - -// ModifyVpcEndpointConnectionNotificationWithContext mocks base method. -func (m *MockEC2) ModifyVpcEndpointConnectionNotificationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointConnectionNotificationWithContext indicates an expected call of ModifyVpcEndpointConnectionNotificationWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointConnectionNotificationWithContext(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, "ModifyVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointConnectionNotificationWithContext), varargs...) -} - -// ModifyVpcEndpointRequest mocks base method. -func (m *MockEC2) ModifyVpcEndpointRequest(arg0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcEndpointOutput) - return ret0, ret1 -} - -// ModifyVpcEndpointRequest indicates an expected call of ModifyVpcEndpointRequest. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointRequest), arg0) -} - -// ModifyVpcEndpointServiceConfiguration mocks base method. -func (m *MockEC2) ModifyVpcEndpointServiceConfiguration(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfiguration", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServiceConfiguration indicates an expected call of ModifyVpcEndpointServiceConfiguration. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServiceConfiguration), arg0) -} - -// ModifyVpcEndpointServiceConfigurationRequest mocks base method. -func (m *MockEC2) ModifyVpcEndpointServiceConfigurationRequest(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) - return ret0, ret1 -} - -// ModifyVpcEndpointServiceConfigurationRequest indicates an expected call of ModifyVpcEndpointServiceConfigurationRequest. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0) -} - -// ModifyVpcEndpointServiceConfigurationWithContext mocks base method. -func (m *MockEC2) ModifyVpcEndpointServiceConfigurationWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServiceConfigurationWithContext indicates an expected call of ModifyVpcEndpointServiceConfigurationWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServiceConfigurationWithContext(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, "ModifyVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServiceConfigurationWithContext), varargs...) -} - -// ModifyVpcEndpointServicePayerResponsibility mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePayerResponsibility(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibility", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePayerResponsibility indicates an expected call of ModifyVpcEndpointServicePayerResponsibility. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePayerResponsibility(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibility", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePayerResponsibility), arg0) -} - -// ModifyVpcEndpointServicePayerResponsibilityRequest mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput) (*request.Request, *ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePayerResponsibilityRequest indicates an expected call of ModifyVpcEndpointServicePayerResponsibilityRequest. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePayerResponsibilityRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePayerResponsibilityRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePayerResponsibilityRequest), arg0) -} - -// ModifyVpcEndpointServicePayerResponsibilityWithContext mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePayerResponsibilityWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePayerResponsibilityInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePayerResponsibilityWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePayerResponsibilityOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePayerResponsibilityWithContext indicates an expected call of ModifyVpcEndpointServicePayerResponsibilityWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePayerResponsibilityWithContext(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, "ModifyVpcEndpointServicePayerResponsibilityWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePayerResponsibilityWithContext), varargs...) -} - -// ModifyVpcEndpointServicePermissions mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePermissions(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissions", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePermissions indicates an expected call of ModifyVpcEndpointServicePermissions. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePermissions), arg0) -} - -// ModifyVpcEndpointServicePermissionsRequest mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePermissionsRequest(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePermissionsOutput) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePermissionsRequest indicates an expected call of ModifyVpcEndpointServicePermissionsRequest. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0) -} - -// ModifyVpcEndpointServicePermissionsWithContext mocks base method. -func (m *MockEC2) ModifyVpcEndpointServicePermissionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointServicePermissionsWithContext indicates an expected call of ModifyVpcEndpointServicePermissionsWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointServicePermissionsWithContext(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, "ModifyVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointServicePermissionsWithContext), varargs...) -} - -// ModifyVpcEndpointWithContext mocks base method. -func (m *MockEC2) ModifyVpcEndpointWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcEndpointWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcEndpointWithContext indicates an expected call of ModifyVpcEndpointWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcEndpointWithContext(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, "ModifyVpcEndpointWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcEndpointWithContext), varargs...) -} - -// ModifyVpcPeeringConnectionOptions mocks base method. -func (m *MockEC2) ModifyVpcPeeringConnectionOptions(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcPeeringConnectionOptions indicates an expected call of ModifyVpcPeeringConnectionOptions. -func (mr *MockEC2MockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2)(nil).ModifyVpcPeeringConnectionOptions), arg0) -} - -// ModifyVpcPeeringConnectionOptionsRequest mocks base method. -func (m *MockEC2) ModifyVpcPeeringConnectionOptionsRequest(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) - return ret0, ret1 -} - -// ModifyVpcPeeringConnectionOptionsRequest indicates an expected call of ModifyVpcPeeringConnectionOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0) -} - -// ModifyVpcPeeringConnectionOptionsWithContext mocks base method. -func (m *MockEC2) ModifyVpcPeeringConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcPeeringConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcPeeringConnectionOptionsWithContext indicates an expected call of ModifyVpcPeeringConnectionOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcPeeringConnectionOptionsWithContext(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, "ModifyVpcPeeringConnectionOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcPeeringConnectionOptionsWithContext), varargs...) -} - -// ModifyVpcTenancy mocks base method. -func (m *MockEC2) ModifyVpcTenancy(arg0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcTenancy", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcTenancy indicates an expected call of ModifyVpcTenancy. -func (mr *MockEC2MockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2)(nil).ModifyVpcTenancy), arg0) -} - -// ModifyVpcTenancyRequest mocks base method. -func (m *MockEC2) ModifyVpcTenancyRequest(arg0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpcTenancyRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpcTenancyOutput) - return ret0, ret1 -} - -// ModifyVpcTenancyRequest indicates an expected call of ModifyVpcTenancyRequest. -func (mr *MockEC2MockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpcTenancyRequest), arg0) -} - -// ModifyVpcTenancyWithContext mocks base method. -func (m *MockEC2) ModifyVpcTenancyWithContext(arg0 context.Context, arg1 *ec2.ModifyVpcTenancyInput, arg2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpcTenancyWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpcTenancyWithContext indicates an expected call of ModifyVpcTenancyWithContext. -func (mr *MockEC2MockRecorder) ModifyVpcTenancyWithContext(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, "ModifyVpcTenancyWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpcTenancyWithContext), varargs...) -} - -// ModifyVpnConnection mocks base method. -func (m *MockEC2) ModifyVpnConnection(arg0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnConnection", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnConnection indicates an expected call of ModifyVpnConnection. -func (mr *MockEC2MockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnection), arg0) -} - -// ModifyVpnConnectionOptions mocks base method. -func (m *MockEC2) ModifyVpnConnectionOptions(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*ec2.ModifyVpnConnectionOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnConnectionOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnConnectionOptions indicates an expected call of ModifyVpnConnectionOptions. -func (mr *MockEC2MockRecorder) ModifyVpnConnectionOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptions", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnectionOptions), arg0) -} - -// ModifyVpnConnectionOptionsRequest mocks base method. -func (m *MockEC2) ModifyVpnConnectionOptionsRequest(arg0 *ec2.ModifyVpnConnectionOptionsInput) (*request.Request, *ec2.ModifyVpnConnectionOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOptionsOutput) - return ret0, ret1 -} - -// ModifyVpnConnectionOptionsRequest indicates an expected call of ModifyVpnConnectionOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyVpnConnectionOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnectionOptionsRequest), arg0) -} - -// ModifyVpnConnectionOptionsWithContext mocks base method. -func (m *MockEC2) ModifyVpnConnectionOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpnConnectionOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnConnectionOptionsWithContext indicates an expected call of ModifyVpnConnectionOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyVpnConnectionOptionsWithContext(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, "ModifyVpnConnectionOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnectionOptionsWithContext), varargs...) -} - -// ModifyVpnConnectionRequest mocks base method. -func (m *MockEC2) ModifyVpnConnectionRequest(arg0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOutput) - return ret0, ret1 -} - -// ModifyVpnConnectionRequest indicates an expected call of ModifyVpnConnectionRequest. -func (mr *MockEC2MockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnectionRequest), arg0) -} - -// ModifyVpnConnectionWithContext mocks base method. -func (m *MockEC2) ModifyVpnConnectionWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnConnectionInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpnConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnConnectionWithContext indicates an expected call of ModifyVpnConnectionWithContext. -func (mr *MockEC2MockRecorder) ModifyVpnConnectionWithContext(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, "ModifyVpnConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpnConnectionWithContext), varargs...) -} - -// ModifyVpnTunnelCertificate mocks base method. -func (m *MockEC2) ModifyVpnTunnelCertificate(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificate", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnTunnelCertificate indicates an expected call of ModifyVpnTunnelCertificate. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelCertificate), arg0) -} - -// ModifyVpnTunnelCertificateRequest mocks base method. -func (m *MockEC2) ModifyVpnTunnelCertificateRequest(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpnTunnelCertificateOutput) - return ret0, ret1 -} - -// ModifyVpnTunnelCertificateRequest indicates an expected call of ModifyVpnTunnelCertificateRequest. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelCertificateRequest), arg0) -} - -// ModifyVpnTunnelCertificateWithContext mocks base method. -func (m *MockEC2) ModifyVpnTunnelCertificateWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelCertificateInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnTunnelCertificateWithContext indicates an expected call of ModifyVpnTunnelCertificateWithContext. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelCertificateWithContext(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, "ModifyVpnTunnelCertificateWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelCertificateWithContext), varargs...) -} - -// ModifyVpnTunnelOptions mocks base method. -func (m *MockEC2) ModifyVpnTunnelOptions(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnTunnelOptions", arg0) - ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnTunnelOptions indicates an expected call of ModifyVpnTunnelOptions. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelOptions), arg0) -} - -// ModifyVpnTunnelOptionsRequest mocks base method. -func (m *MockEC2) ModifyVpnTunnelOptionsRequest(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ModifyVpnTunnelOptionsOutput) - return ret0, ret1 -} - -// ModifyVpnTunnelOptionsRequest indicates an expected call of ModifyVpnTunnelOptionsRequest. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelOptionsRequest), arg0) -} - -// ModifyVpnTunnelOptionsWithContext mocks base method. -func (m *MockEC2) ModifyVpnTunnelOptionsWithContext(arg0 context.Context, arg1 *ec2.ModifyVpnTunnelOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyVpnTunnelOptionsWithContext indicates an expected call of ModifyVpnTunnelOptionsWithContext. -func (mr *MockEC2MockRecorder) ModifyVpnTunnelOptionsWithContext(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, "ModifyVpnTunnelOptionsWithContext", reflect.TypeOf((*MockEC2)(nil).ModifyVpnTunnelOptionsWithContext), varargs...) -} - -// MonitorInstances mocks base method. -func (m *MockEC2) MonitorInstances(arg0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MonitorInstances", arg0) - ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MonitorInstances indicates an expected call of MonitorInstances. -func (mr *MockEC2MockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2)(nil).MonitorInstances), arg0) -} - -// MonitorInstancesRequest mocks base method. -func (m *MockEC2) MonitorInstancesRequest(arg0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MonitorInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.MonitorInstancesOutput) - return ret0, ret1 -} - -// MonitorInstancesRequest indicates an expected call of MonitorInstancesRequest. -func (mr *MockEC2MockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2)(nil).MonitorInstancesRequest), arg0) -} - -// MonitorInstancesWithContext mocks base method. -func (m *MockEC2) MonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.MonitorInstancesInput, arg2 ...request.Option) (*ec2.MonitorInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "MonitorInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MonitorInstancesWithContext indicates an expected call of MonitorInstancesWithContext. -func (mr *MockEC2MockRecorder) MonitorInstancesWithContext(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, "MonitorInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).MonitorInstancesWithContext), varargs...) -} - -// MoveAddressToVpc mocks base method. -func (m *MockEC2) MoveAddressToVpc(arg0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MoveAddressToVpc", arg0) - ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MoveAddressToVpc indicates an expected call of MoveAddressToVpc. -func (mr *MockEC2MockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2)(nil).MoveAddressToVpc), arg0) -} - -// MoveAddressToVpcRequest mocks base method. -func (m *MockEC2) MoveAddressToVpcRequest(arg0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MoveAddressToVpcRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.MoveAddressToVpcOutput) - return ret0, ret1 -} - -// MoveAddressToVpcRequest indicates an expected call of MoveAddressToVpcRequest. -func (mr *MockEC2MockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2)(nil).MoveAddressToVpcRequest), arg0) -} - -// MoveAddressToVpcWithContext mocks base method. -func (m *MockEC2) MoveAddressToVpcWithContext(arg0 context.Context, arg1 *ec2.MoveAddressToVpcInput, arg2 ...request.Option) (*ec2.MoveAddressToVpcOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "MoveAddressToVpcWithContext", varargs...) - ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MoveAddressToVpcWithContext indicates an expected call of MoveAddressToVpcWithContext. -func (mr *MockEC2MockRecorder) MoveAddressToVpcWithContext(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, "MoveAddressToVpcWithContext", reflect.TypeOf((*MockEC2)(nil).MoveAddressToVpcWithContext), varargs...) -} - -// MoveByoipCidrToIpam mocks base method. -func (m *MockEC2) MoveByoipCidrToIpam(arg0 *ec2.MoveByoipCidrToIpamInput) (*ec2.MoveByoipCidrToIpamOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MoveByoipCidrToIpam", arg0) - ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MoveByoipCidrToIpam indicates an expected call of MoveByoipCidrToIpam. -func (mr *MockEC2MockRecorder) MoveByoipCidrToIpam(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpam", reflect.TypeOf((*MockEC2)(nil).MoveByoipCidrToIpam), arg0) -} - -// MoveByoipCidrToIpamRequest mocks base method. -func (m *MockEC2) MoveByoipCidrToIpamRequest(arg0 *ec2.MoveByoipCidrToIpamInput) (*request.Request, *ec2.MoveByoipCidrToIpamOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "MoveByoipCidrToIpamRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.MoveByoipCidrToIpamOutput) - return ret0, ret1 -} - -// MoveByoipCidrToIpamRequest indicates an expected call of MoveByoipCidrToIpamRequest. -func (mr *MockEC2MockRecorder) MoveByoipCidrToIpamRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveByoipCidrToIpamRequest", reflect.TypeOf((*MockEC2)(nil).MoveByoipCidrToIpamRequest), arg0) -} - -// MoveByoipCidrToIpamWithContext mocks base method. -func (m *MockEC2) MoveByoipCidrToIpamWithContext(arg0 context.Context, arg1 *ec2.MoveByoipCidrToIpamInput, arg2 ...request.Option) (*ec2.MoveByoipCidrToIpamOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "MoveByoipCidrToIpamWithContext", varargs...) - ret0, _ := ret[0].(*ec2.MoveByoipCidrToIpamOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// MoveByoipCidrToIpamWithContext indicates an expected call of MoveByoipCidrToIpamWithContext. -func (mr *MockEC2MockRecorder) MoveByoipCidrToIpamWithContext(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, "MoveByoipCidrToIpamWithContext", reflect.TypeOf((*MockEC2)(nil).MoveByoipCidrToIpamWithContext), varargs...) -} - -// ProvisionByoipCidr mocks base method. -func (m *MockEC2) ProvisionByoipCidr(arg0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionByoipCidr", arg0) - ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionByoipCidr indicates an expected call of ProvisionByoipCidr. -func (mr *MockEC2MockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2)(nil).ProvisionByoipCidr), arg0) -} - -// ProvisionByoipCidrRequest mocks base method. -func (m *MockEC2) ProvisionByoipCidrRequest(arg0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionByoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ProvisionByoipCidrOutput) - return ret0, ret1 -} - -// ProvisionByoipCidrRequest indicates an expected call of ProvisionByoipCidrRequest. -func (mr *MockEC2MockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).ProvisionByoipCidrRequest), arg0) -} - -// ProvisionByoipCidrWithContext mocks base method. -func (m *MockEC2) ProvisionByoipCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionByoipCidrInput, arg2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ProvisionByoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionByoipCidrWithContext indicates an expected call of ProvisionByoipCidrWithContext. -func (mr *MockEC2MockRecorder) ProvisionByoipCidrWithContext(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, "ProvisionByoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).ProvisionByoipCidrWithContext), varargs...) -} - -// ProvisionIpamByoasn mocks base method. -func (m *MockEC2) ProvisionIpamByoasn(arg0 *ec2.ProvisionIpamByoasnInput) (*ec2.ProvisionIpamByoasnOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionIpamByoasn", arg0) - ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionIpamByoasn indicates an expected call of ProvisionIpamByoasn. -func (mr *MockEC2MockRecorder) ProvisionIpamByoasn(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasn", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamByoasn), arg0) -} - -// ProvisionIpamByoasnRequest mocks base method. -func (m *MockEC2) ProvisionIpamByoasnRequest(arg0 *ec2.ProvisionIpamByoasnInput) (*request.Request, *ec2.ProvisionIpamByoasnOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionIpamByoasnRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ProvisionIpamByoasnOutput) - return ret0, ret1 -} - -// ProvisionIpamByoasnRequest indicates an expected call of ProvisionIpamByoasnRequest. -func (mr *MockEC2MockRecorder) ProvisionIpamByoasnRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamByoasnRequest", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamByoasnRequest), arg0) -} - -// ProvisionIpamByoasnWithContext mocks base method. -func (m *MockEC2) ProvisionIpamByoasnWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamByoasnInput, arg2 ...request.Option) (*ec2.ProvisionIpamByoasnOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ProvisionIpamByoasnWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ProvisionIpamByoasnOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionIpamByoasnWithContext indicates an expected call of ProvisionIpamByoasnWithContext. -func (mr *MockEC2MockRecorder) ProvisionIpamByoasnWithContext(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, "ProvisionIpamByoasnWithContext", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamByoasnWithContext), varargs...) -} - -// ProvisionIpamPoolCidr mocks base method. -func (m *MockEC2) ProvisionIpamPoolCidr(arg0 *ec2.ProvisionIpamPoolCidrInput) (*ec2.ProvisionIpamPoolCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionIpamPoolCidr", arg0) - ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionIpamPoolCidr indicates an expected call of ProvisionIpamPoolCidr. -func (mr *MockEC2MockRecorder) ProvisionIpamPoolCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidr", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamPoolCidr), arg0) -} - -// ProvisionIpamPoolCidrRequest mocks base method. -func (m *MockEC2) ProvisionIpamPoolCidrRequest(arg0 *ec2.ProvisionIpamPoolCidrInput) (*request.Request, *ec2.ProvisionIpamPoolCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ProvisionIpamPoolCidrOutput) - return ret0, ret1 -} - -// ProvisionIpamPoolCidrRequest indicates an expected call of ProvisionIpamPoolCidrRequest. -func (mr *MockEC2MockRecorder) ProvisionIpamPoolCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionIpamPoolCidrRequest", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamPoolCidrRequest), arg0) -} - -// ProvisionIpamPoolCidrWithContext mocks base method. -func (m *MockEC2) ProvisionIpamPoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionIpamPoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionIpamPoolCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ProvisionIpamPoolCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ProvisionIpamPoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionIpamPoolCidrWithContext indicates an expected call of ProvisionIpamPoolCidrWithContext. -func (mr *MockEC2MockRecorder) ProvisionIpamPoolCidrWithContext(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, "ProvisionIpamPoolCidrWithContext", reflect.TypeOf((*MockEC2)(nil).ProvisionIpamPoolCidrWithContext), varargs...) -} - -// ProvisionPublicIpv4PoolCidr mocks base method. -func (m *MockEC2) ProvisionPublicIpv4PoolCidr(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidr", arg0) - ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionPublicIpv4PoolCidr indicates an expected call of ProvisionPublicIpv4PoolCidr. -func (mr *MockEC2MockRecorder) ProvisionPublicIpv4PoolCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidr", reflect.TypeOf((*MockEC2)(nil).ProvisionPublicIpv4PoolCidr), arg0) -} - -// ProvisionPublicIpv4PoolCidrRequest mocks base method. -func (m *MockEC2) ProvisionPublicIpv4PoolCidrRequest(arg0 *ec2.ProvisionPublicIpv4PoolCidrInput) (*request.Request, *ec2.ProvisionPublicIpv4PoolCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ProvisionPublicIpv4PoolCidrOutput) - return ret0, ret1 -} - -// ProvisionPublicIpv4PoolCidrRequest indicates an expected call of ProvisionPublicIpv4PoolCidrRequest. -func (mr *MockEC2MockRecorder) ProvisionPublicIpv4PoolCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionPublicIpv4PoolCidrRequest", reflect.TypeOf((*MockEC2)(nil).ProvisionPublicIpv4PoolCidrRequest), arg0) -} - -// ProvisionPublicIpv4PoolCidrWithContext mocks base method. -func (m *MockEC2) ProvisionPublicIpv4PoolCidrWithContext(arg0 context.Context, arg1 *ec2.ProvisionPublicIpv4PoolCidrInput, arg2 ...request.Option) (*ec2.ProvisionPublicIpv4PoolCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ProvisionPublicIpv4PoolCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ProvisionPublicIpv4PoolCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ProvisionPublicIpv4PoolCidrWithContext indicates an expected call of ProvisionPublicIpv4PoolCidrWithContext. -func (mr *MockEC2MockRecorder) ProvisionPublicIpv4PoolCidrWithContext(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, "ProvisionPublicIpv4PoolCidrWithContext", reflect.TypeOf((*MockEC2)(nil).ProvisionPublicIpv4PoolCidrWithContext), varargs...) -} - -// PurchaseCapacityBlock mocks base method. -func (m *MockEC2) PurchaseCapacityBlock(arg0 *ec2.PurchaseCapacityBlockInput) (*ec2.PurchaseCapacityBlockOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseCapacityBlock", arg0) - ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseCapacityBlock indicates an expected call of PurchaseCapacityBlock. -func (mr *MockEC2MockRecorder) PurchaseCapacityBlock(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlock", reflect.TypeOf((*MockEC2)(nil).PurchaseCapacityBlock), arg0) -} - -// PurchaseCapacityBlockRequest mocks base method. -func (m *MockEC2) PurchaseCapacityBlockRequest(arg0 *ec2.PurchaseCapacityBlockInput) (*request.Request, *ec2.PurchaseCapacityBlockOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseCapacityBlockRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.PurchaseCapacityBlockOutput) - return ret0, ret1 -} - -// PurchaseCapacityBlockRequest indicates an expected call of PurchaseCapacityBlockRequest. -func (mr *MockEC2MockRecorder) PurchaseCapacityBlockRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlockRequest", reflect.TypeOf((*MockEC2)(nil).PurchaseCapacityBlockRequest), arg0) -} - -// PurchaseCapacityBlockWithContext mocks base method. -func (m *MockEC2) PurchaseCapacityBlockWithContext(arg0 context.Context, arg1 *ec2.PurchaseCapacityBlockInput, arg2 ...request.Option) (*ec2.PurchaseCapacityBlockOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PurchaseCapacityBlockWithContext", varargs...) - ret0, _ := ret[0].(*ec2.PurchaseCapacityBlockOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseCapacityBlockWithContext indicates an expected call of PurchaseCapacityBlockWithContext. -func (mr *MockEC2MockRecorder) PurchaseCapacityBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseCapacityBlockWithContext", reflect.TypeOf((*MockEC2)(nil).PurchaseCapacityBlockWithContext), varargs...) -} - -// PurchaseHostReservation mocks base method. -func (m *MockEC2) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseHostReservation", arg0) - ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseHostReservation indicates an expected call of PurchaseHostReservation. -func (mr *MockEC2MockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2)(nil).PurchaseHostReservation), arg0) -} - -// PurchaseHostReservationRequest mocks base method. -func (m *MockEC2) PurchaseHostReservationRequest(arg0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseHostReservationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.PurchaseHostReservationOutput) - return ret0, ret1 -} - -// PurchaseHostReservationRequest indicates an expected call of PurchaseHostReservationRequest. -func (mr *MockEC2MockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2)(nil).PurchaseHostReservationRequest), arg0) -} - -// PurchaseHostReservationWithContext mocks base method. -func (m *MockEC2) PurchaseHostReservationWithContext(arg0 context.Context, arg1 *ec2.PurchaseHostReservationInput, arg2 ...request.Option) (*ec2.PurchaseHostReservationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PurchaseHostReservationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseHostReservationWithContext indicates an expected call of PurchaseHostReservationWithContext. -func (mr *MockEC2MockRecorder) PurchaseHostReservationWithContext(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, "PurchaseHostReservationWithContext", reflect.TypeOf((*MockEC2)(nil).PurchaseHostReservationWithContext), varargs...) -} - -// PurchaseReservedInstancesOffering mocks base method. -func (m *MockEC2) PurchaseReservedInstancesOffering(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseReservedInstancesOffering", arg0) - ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseReservedInstancesOffering indicates an expected call of PurchaseReservedInstancesOffering. -func (mr *MockEC2MockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2)(nil).PurchaseReservedInstancesOffering), arg0) -} - -// PurchaseReservedInstancesOfferingRequest mocks base method. -func (m *MockEC2) PurchaseReservedInstancesOfferingRequest(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.PurchaseReservedInstancesOfferingOutput) - return ret0, ret1 -} - -// PurchaseReservedInstancesOfferingRequest indicates an expected call of PurchaseReservedInstancesOfferingRequest. -func (mr *MockEC2MockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2)(nil).PurchaseReservedInstancesOfferingRequest), arg0) -} - -// PurchaseReservedInstancesOfferingWithContext mocks base method. -func (m *MockEC2) PurchaseReservedInstancesOfferingWithContext(arg0 context.Context, arg1 *ec2.PurchaseReservedInstancesOfferingInput, arg2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingWithContext", varargs...) - ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseReservedInstancesOfferingWithContext indicates an expected call of PurchaseReservedInstancesOfferingWithContext. -func (mr *MockEC2MockRecorder) PurchaseReservedInstancesOfferingWithContext(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, "PurchaseReservedInstancesOfferingWithContext", reflect.TypeOf((*MockEC2)(nil).PurchaseReservedInstancesOfferingWithContext), varargs...) -} - -// PurchaseScheduledInstances mocks base method. -func (m *MockEC2) PurchaseScheduledInstances(arg0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseScheduledInstances", arg0) - ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseScheduledInstances indicates an expected call of PurchaseScheduledInstances. -func (mr *MockEC2MockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2)(nil).PurchaseScheduledInstances), arg0) -} - -// PurchaseScheduledInstancesRequest mocks base method. -func (m *MockEC2) PurchaseScheduledInstancesRequest(arg0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PurchaseScheduledInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.PurchaseScheduledInstancesOutput) - return ret0, ret1 -} - -// PurchaseScheduledInstancesRequest indicates an expected call of PurchaseScheduledInstancesRequest. -func (mr *MockEC2MockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2)(nil).PurchaseScheduledInstancesRequest), arg0) -} - -// PurchaseScheduledInstancesWithContext mocks base method. -func (m *MockEC2) PurchaseScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.PurchaseScheduledInstancesInput, arg2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "PurchaseScheduledInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// PurchaseScheduledInstancesWithContext indicates an expected call of PurchaseScheduledInstancesWithContext. -func (mr *MockEC2MockRecorder) PurchaseScheduledInstancesWithContext(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, "PurchaseScheduledInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).PurchaseScheduledInstancesWithContext), varargs...) -} - -// RebootInstances mocks base method. -func (m *MockEC2) RebootInstances(arg0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RebootInstances", arg0) - ret0, _ := ret[0].(*ec2.RebootInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RebootInstances indicates an expected call of RebootInstances. -func (mr *MockEC2MockRecorder) RebootInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2)(nil).RebootInstances), arg0) -} - -// RebootInstancesRequest mocks base method. -func (m *MockEC2) RebootInstancesRequest(arg0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RebootInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RebootInstancesOutput) - return ret0, ret1 -} - -// RebootInstancesRequest indicates an expected call of RebootInstancesRequest. -func (mr *MockEC2MockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2)(nil).RebootInstancesRequest), arg0) -} - -// RebootInstancesWithContext mocks base method. -func (m *MockEC2) RebootInstancesWithContext(arg0 context.Context, arg1 *ec2.RebootInstancesInput, arg2 ...request.Option) (*ec2.RebootInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RebootInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RebootInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RebootInstancesWithContext indicates an expected call of RebootInstancesWithContext. -func (mr *MockEC2MockRecorder) RebootInstancesWithContext(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, "RebootInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).RebootInstancesWithContext), varargs...) -} - -// RegisterImage mocks base method. -func (m *MockEC2) RegisterImage(arg0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterImage", arg0) - ret0, _ := ret[0].(*ec2.RegisterImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterImage indicates an expected call of RegisterImage. -func (mr *MockEC2MockRecorder) RegisterImage(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2)(nil).RegisterImage), arg0) -} - -// RegisterImageRequest mocks base method. -func (m *MockEC2) RegisterImageRequest(arg0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterImageRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RegisterImageOutput) - return ret0, ret1 -} - -// RegisterImageRequest indicates an expected call of RegisterImageRequest. -func (mr *MockEC2MockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2)(nil).RegisterImageRequest), arg0) -} - -// RegisterImageWithContext mocks base method. -func (m *MockEC2) RegisterImageWithContext(arg0 context.Context, arg1 *ec2.RegisterImageInput, arg2 ...request.Option) (*ec2.RegisterImageOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterImageWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RegisterImageOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterImageWithContext indicates an expected call of RegisterImageWithContext. -func (mr *MockEC2MockRecorder) RegisterImageWithContext(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, "RegisterImageWithContext", reflect.TypeOf((*MockEC2)(nil).RegisterImageWithContext), varargs...) -} - -// RegisterInstanceEventNotificationAttributes mocks base method. -func (m *MockEC2) RegisterInstanceEventNotificationAttributes(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributes", arg0) - ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterInstanceEventNotificationAttributes indicates an expected call of RegisterInstanceEventNotificationAttributes. -func (mr *MockEC2MockRecorder) RegisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2)(nil).RegisterInstanceEventNotificationAttributes), arg0) -} - -// RegisterInstanceEventNotificationAttributesRequest mocks base method. -func (m *MockEC2) RegisterInstanceEventNotificationAttributesRequest(arg0 *ec2.RegisterInstanceEventNotificationAttributesInput) (*request.Request, *ec2.RegisterInstanceEventNotificationAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RegisterInstanceEventNotificationAttributesOutput) - return ret0, ret1 -} - -// RegisterInstanceEventNotificationAttributesRequest indicates an expected call of RegisterInstanceEventNotificationAttributesRequest. -func (mr *MockEC2MockRecorder) RegisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2)(nil).RegisterInstanceEventNotificationAttributesRequest), arg0) -} - -// RegisterInstanceEventNotificationAttributesWithContext mocks base method. -func (m *MockEC2) RegisterInstanceEventNotificationAttributesWithContext(arg0 context.Context, arg1 *ec2.RegisterInstanceEventNotificationAttributesInput, arg2 ...request.Option) (*ec2.RegisterInstanceEventNotificationAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterInstanceEventNotificationAttributesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RegisterInstanceEventNotificationAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterInstanceEventNotificationAttributesWithContext indicates an expected call of RegisterInstanceEventNotificationAttributesWithContext. -func (mr *MockEC2MockRecorder) RegisterInstanceEventNotificationAttributesWithContext(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, "RegisterInstanceEventNotificationAttributesWithContext", reflect.TypeOf((*MockEC2)(nil).RegisterInstanceEventNotificationAttributesWithContext), varargs...) -} - -// RegisterTransitGatewayMulticastGroupMembers mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupMembers(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembers", arg0) - ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupMembers indicates an expected call of RegisterTransitGatewayMulticastGroupMembers. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupMembers), arg0) -} - -// RegisterTransitGatewayMulticastGroupMembersRequest mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupMembersInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupMembersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupMembersRequest indicates an expected call of RegisterTransitGatewayMulticastGroupMembersRequest. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupMembersRequest), arg0) -} - -// RegisterTransitGatewayMulticastGroupMembersWithContext mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupMembersInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupMembersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupMembersWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupMembersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupMembersWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupMembersWithContext. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupMembersWithContext(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, "RegisterTransitGatewayMulticastGroupMembersWithContext", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupMembersWithContext), varargs...) -} - -// RegisterTransitGatewayMulticastGroupSources mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupSources(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSources", arg0) - ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupSources indicates an expected call of RegisterTransitGatewayMulticastGroupSources. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupSources), arg0) -} - -// RegisterTransitGatewayMulticastGroupSourcesRequest mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput) (*request.Request, *ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupSourcesRequest indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesRequest. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupSourcesRequest), arg0) -} - -// RegisterTransitGatewayMulticastGroupSourcesWithContext mocks base method. -func (m *MockEC2) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0 context.Context, arg1 *ec2.RegisterTransitGatewayMulticastGroupSourcesInput, arg2 ...request.Option) (*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterTransitGatewayMulticastGroupSourcesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RegisterTransitGatewayMulticastGroupSourcesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTransitGatewayMulticastGroupSourcesWithContext indicates an expected call of RegisterTransitGatewayMulticastGroupSourcesWithContext. -func (mr *MockEC2MockRecorder) RegisterTransitGatewayMulticastGroupSourcesWithContext(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, "RegisterTransitGatewayMulticastGroupSourcesWithContext", reflect.TypeOf((*MockEC2)(nil).RegisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) -} - -// RejectTransitGatewayMulticastDomainAssociations mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) RejectTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayMulticastDomainAssociations), arg0) -} - -// RejectTransitGatewayMulticastDomainAssociationsRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) RejectTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayMulticastDomainAssociationsRequest), arg0) -} - -// RejectTransitGatewayMulticastDomainAssociationsWithContext mocks base method. -func (m *MockEC2) RejectTransitGatewayMulticastDomainAssociationsWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).RejectTransitGatewayMulticastDomainAssociationsWithContext), varargs...) -} - -// RejectTransitGatewayPeeringAttachment mocks base method. -func (m *MockEC2) RejectTransitGatewayPeeringAttachment(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachment", arg0) - ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectTransitGatewayPeeringAttachment indicates an expected call of RejectTransitGatewayPeeringAttachment. -func (mr *MockEC2MockRecorder) RejectTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayPeeringAttachment), arg0) -} - -// RejectTransitGatewayPeeringAttachmentRequest mocks base method. -func (m *MockEC2) RejectTransitGatewayPeeringAttachmentRequest(arg0 *ec2.RejectTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayPeeringAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) - return ret0, ret1 -} - -// RejectTransitGatewayPeeringAttachmentRequest indicates an expected call of RejectTransitGatewayPeeringAttachmentRequest. -func (mr *MockEC2MockRecorder) RejectTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayPeeringAttachmentRequest), arg0) -} - -// RejectTransitGatewayPeeringAttachmentWithContext mocks base method. -func (m *MockEC2) RejectTransitGatewayPeeringAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayPeeringAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RejectTransitGatewayPeeringAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RejectTransitGatewayPeeringAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectTransitGatewayPeeringAttachmentWithContext indicates an expected call of RejectTransitGatewayPeeringAttachmentWithContext. -func (mr *MockEC2MockRecorder) RejectTransitGatewayPeeringAttachmentWithContext(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, "RejectTransitGatewayPeeringAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayPeeringAttachmentWithContext), varargs...) -} - -// RejectTransitGatewayVpcAttachment mocks base method. -func (m *MockEC2) RejectTransitGatewayVpcAttachment(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachment", arg0) - ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectTransitGatewayVpcAttachment indicates an expected call of RejectTransitGatewayVpcAttachment. -func (mr *MockEC2MockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayVpcAttachment), arg0) -} - -// RejectTransitGatewayVpcAttachmentRequest mocks base method. -func (m *MockEC2) RejectTransitGatewayVpcAttachmentRequest(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RejectTransitGatewayVpcAttachmentOutput) - return ret0, ret1 -} - -// RejectTransitGatewayVpcAttachmentRequest indicates an expected call of RejectTransitGatewayVpcAttachmentRequest. -func (mr *MockEC2MockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0) -} - -// RejectTransitGatewayVpcAttachmentWithContext mocks base method. -func (m *MockEC2) RejectTransitGatewayVpcAttachmentWithContext(arg0 context.Context, arg1 *ec2.RejectTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectTransitGatewayVpcAttachmentWithContext indicates an expected call of RejectTransitGatewayVpcAttachmentWithContext. -func (mr *MockEC2MockRecorder) RejectTransitGatewayVpcAttachmentWithContext(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, "RejectTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2)(nil).RejectTransitGatewayVpcAttachmentWithContext), varargs...) -} - -// RejectVpcEndpointConnections mocks base method. -func (m *MockEC2) RejectVpcEndpointConnections(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", arg0) - ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections. -func (mr *MockEC2MockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2)(nil).RejectVpcEndpointConnections), arg0) -} - -// RejectVpcEndpointConnectionsRequest mocks base method. -func (m *MockEC2) RejectVpcEndpointConnectionsRequest(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RejectVpcEndpointConnectionsOutput) - return ret0, ret1 -} - -// RejectVpcEndpointConnectionsRequest indicates an expected call of RejectVpcEndpointConnectionsRequest. -func (mr *MockEC2MockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).RejectVpcEndpointConnectionsRequest), arg0) -} - -// RejectVpcEndpointConnectionsWithContext mocks base method. -func (m *MockEC2) RejectVpcEndpointConnectionsWithContext(arg0 context.Context, arg1 *ec2.RejectVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectVpcEndpointConnectionsWithContext indicates an expected call of RejectVpcEndpointConnectionsWithContext. -func (mr *MockEC2MockRecorder) RejectVpcEndpointConnectionsWithContext(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, "RejectVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).RejectVpcEndpointConnectionsWithContext), varargs...) -} - -// RejectVpcPeeringConnection mocks base method. -func (m *MockEC2) RejectVpcPeeringConnection(arg0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectVpcPeeringConnection", arg0) - ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectVpcPeeringConnection indicates an expected call of RejectVpcPeeringConnection. -func (mr *MockEC2MockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2)(nil).RejectVpcPeeringConnection), arg0) -} - -// RejectVpcPeeringConnectionRequest mocks base method. -func (m *MockEC2) RejectVpcPeeringConnectionRequest(arg0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RejectVpcPeeringConnectionOutput) - return ret0, ret1 -} - -// RejectVpcPeeringConnectionRequest indicates an expected call of RejectVpcPeeringConnectionRequest. -func (mr *MockEC2MockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2)(nil).RejectVpcPeeringConnectionRequest), arg0) -} - -// RejectVpcPeeringConnectionWithContext mocks base method. -func (m *MockEC2) RejectVpcPeeringConnectionWithContext(arg0 context.Context, arg1 *ec2.RejectVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RejectVpcPeeringConnectionWithContext indicates an expected call of RejectVpcPeeringConnectionWithContext. -func (mr *MockEC2MockRecorder) RejectVpcPeeringConnectionWithContext(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, "RejectVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2)(nil).RejectVpcPeeringConnectionWithContext), varargs...) -} - -// ReleaseAddress mocks base method. -func (m *MockEC2) ReleaseAddress(arg0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseAddress", arg0) - ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseAddress indicates an expected call of ReleaseAddress. -func (mr *MockEC2MockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2)(nil).ReleaseAddress), arg0) -} - -// ReleaseAddressRequest mocks base method. -func (m *MockEC2) ReleaseAddressRequest(arg0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseAddressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReleaseAddressOutput) - return ret0, ret1 -} - -// ReleaseAddressRequest indicates an expected call of ReleaseAddressRequest. -func (mr *MockEC2MockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2)(nil).ReleaseAddressRequest), arg0) -} - -// ReleaseAddressWithContext mocks base method. -func (m *MockEC2) ReleaseAddressWithContext(arg0 context.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...request.Option) (*ec2.ReleaseAddressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReleaseAddressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseAddressWithContext indicates an expected call of ReleaseAddressWithContext. -func (mr *MockEC2MockRecorder) ReleaseAddressWithContext(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, "ReleaseAddressWithContext", reflect.TypeOf((*MockEC2)(nil).ReleaseAddressWithContext), varargs...) -} - -// ReleaseHosts mocks base method. -func (m *MockEC2) ReleaseHosts(arg0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseHosts", arg0) - ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseHosts indicates an expected call of ReleaseHosts. -func (mr *MockEC2MockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2)(nil).ReleaseHosts), arg0) -} - -// ReleaseHostsRequest mocks base method. -func (m *MockEC2) ReleaseHostsRequest(arg0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseHostsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReleaseHostsOutput) - return ret0, ret1 -} - -// ReleaseHostsRequest indicates an expected call of ReleaseHostsRequest. -func (mr *MockEC2MockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2)(nil).ReleaseHostsRequest), arg0) -} - -// ReleaseHostsWithContext mocks base method. -func (m *MockEC2) ReleaseHostsWithContext(arg0 context.Context, arg1 *ec2.ReleaseHostsInput, arg2 ...request.Option) (*ec2.ReleaseHostsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReleaseHostsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseHostsWithContext indicates an expected call of ReleaseHostsWithContext. -func (mr *MockEC2MockRecorder) ReleaseHostsWithContext(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, "ReleaseHostsWithContext", reflect.TypeOf((*MockEC2)(nil).ReleaseHostsWithContext), varargs...) -} - -// ReleaseIpamPoolAllocation mocks base method. -func (m *MockEC2) ReleaseIpamPoolAllocation(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*ec2.ReleaseIpamPoolAllocationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocation", arg0) - ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseIpamPoolAllocation indicates an expected call of ReleaseIpamPoolAllocation. -func (mr *MockEC2MockRecorder) ReleaseIpamPoolAllocation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocation", reflect.TypeOf((*MockEC2)(nil).ReleaseIpamPoolAllocation), arg0) -} - -// ReleaseIpamPoolAllocationRequest mocks base method. -func (m *MockEC2) ReleaseIpamPoolAllocationRequest(arg0 *ec2.ReleaseIpamPoolAllocationInput) (*request.Request, *ec2.ReleaseIpamPoolAllocationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReleaseIpamPoolAllocationOutput) - return ret0, ret1 -} - -// ReleaseIpamPoolAllocationRequest indicates an expected call of ReleaseIpamPoolAllocationRequest. -func (mr *MockEC2MockRecorder) ReleaseIpamPoolAllocationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseIpamPoolAllocationRequest", reflect.TypeOf((*MockEC2)(nil).ReleaseIpamPoolAllocationRequest), arg0) -} - -// ReleaseIpamPoolAllocationWithContext mocks base method. -func (m *MockEC2) ReleaseIpamPoolAllocationWithContext(arg0 context.Context, arg1 *ec2.ReleaseIpamPoolAllocationInput, arg2 ...request.Option) (*ec2.ReleaseIpamPoolAllocationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReleaseIpamPoolAllocationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReleaseIpamPoolAllocationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReleaseIpamPoolAllocationWithContext indicates an expected call of ReleaseIpamPoolAllocationWithContext. -func (mr *MockEC2MockRecorder) ReleaseIpamPoolAllocationWithContext(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, "ReleaseIpamPoolAllocationWithContext", reflect.TypeOf((*MockEC2)(nil).ReleaseIpamPoolAllocationWithContext), varargs...) -} - -// ReplaceIamInstanceProfileAssociation mocks base method. -func (m *MockEC2) ReplaceIamInstanceProfileAssociation(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociation", arg0) - ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceIamInstanceProfileAssociation indicates an expected call of ReplaceIamInstanceProfileAssociation. -func (mr *MockEC2MockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2)(nil).ReplaceIamInstanceProfileAssociation), arg0) -} - -// ReplaceIamInstanceProfileAssociationRequest mocks base method. -func (m *MockEC2) ReplaceIamInstanceProfileAssociationRequest(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceIamInstanceProfileAssociationOutput) - return ret0, ret1 -} - -// ReplaceIamInstanceProfileAssociationRequest indicates an expected call of ReplaceIamInstanceProfileAssociationRequest. -func (mr *MockEC2MockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0) -} - -// ReplaceIamInstanceProfileAssociationWithContext mocks base method. -func (m *MockEC2) ReplaceIamInstanceProfileAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceIamInstanceProfileAssociationInput, arg2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceIamInstanceProfileAssociationWithContext indicates an expected call of ReplaceIamInstanceProfileAssociationWithContext. -func (mr *MockEC2MockRecorder) ReplaceIamInstanceProfileAssociationWithContext(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, "ReplaceIamInstanceProfileAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceIamInstanceProfileAssociationWithContext), varargs...) -} - -// ReplaceNetworkAclAssociation mocks base method. -func (m *MockEC2) ReplaceNetworkAclAssociation(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociation", arg0) - ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceNetworkAclAssociation indicates an expected call of ReplaceNetworkAclAssociation. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclAssociation), arg0) -} - -// ReplaceNetworkAclAssociationRequest mocks base method. -func (m *MockEC2) ReplaceNetworkAclAssociationRequest(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceNetworkAclAssociationOutput) - return ret0, ret1 -} - -// ReplaceNetworkAclAssociationRequest indicates an expected call of ReplaceNetworkAclAssociationRequest. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclAssociationRequest), arg0) -} - -// ReplaceNetworkAclAssociationWithContext mocks base method. -func (m *MockEC2) ReplaceNetworkAclAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclAssociationInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceNetworkAclAssociationWithContext indicates an expected call of ReplaceNetworkAclAssociationWithContext. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclAssociationWithContext(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, "ReplaceNetworkAclAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclAssociationWithContext), varargs...) -} - -// ReplaceNetworkAclEntry mocks base method. -func (m *MockEC2) ReplaceNetworkAclEntry(arg0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceNetworkAclEntry", arg0) - ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceNetworkAclEntry indicates an expected call of ReplaceNetworkAclEntry. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclEntry), arg0) -} - -// ReplaceNetworkAclEntryRequest mocks base method. -func (m *MockEC2) ReplaceNetworkAclEntryRequest(arg0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceNetworkAclEntryOutput) - return ret0, ret1 -} - -// ReplaceNetworkAclEntryRequest indicates an expected call of ReplaceNetworkAclEntryRequest. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclEntryRequest), arg0) -} - -// ReplaceNetworkAclEntryWithContext mocks base method. -func (m *MockEC2) ReplaceNetworkAclEntryWithContext(arg0 context.Context, arg1 *ec2.ReplaceNetworkAclEntryInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceNetworkAclEntryWithContext indicates an expected call of ReplaceNetworkAclEntryWithContext. -func (mr *MockEC2MockRecorder) ReplaceNetworkAclEntryWithContext(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, "ReplaceNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceNetworkAclEntryWithContext), varargs...) -} - -// ReplaceRoute mocks base method. -func (m *MockEC2) ReplaceRoute(arg0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceRoute", arg0) - ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceRoute indicates an expected call of ReplaceRoute. -func (mr *MockEC2MockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2)(nil).ReplaceRoute), arg0) -} - -// ReplaceRouteRequest mocks base method. -func (m *MockEC2) ReplaceRouteRequest(arg0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceRouteOutput) - return ret0, ret1 -} - -// ReplaceRouteRequest indicates an expected call of ReplaceRouteRequest. -func (mr *MockEC2MockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceRouteRequest), arg0) -} - -// ReplaceRouteTableAssociation mocks base method. -func (m *MockEC2) ReplaceRouteTableAssociation(arg0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceRouteTableAssociation", arg0) - ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceRouteTableAssociation indicates an expected call of ReplaceRouteTableAssociation. -func (mr *MockEC2MockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2)(nil).ReplaceRouteTableAssociation), arg0) -} - -// ReplaceRouteTableAssociationRequest mocks base method. -func (m *MockEC2) ReplaceRouteTableAssociationRequest(arg0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceRouteTableAssociationOutput) - return ret0, ret1 -} - -// ReplaceRouteTableAssociationRequest indicates an expected call of ReplaceRouteTableAssociationRequest. -func (mr *MockEC2MockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceRouteTableAssociationRequest), arg0) -} - -// ReplaceRouteTableAssociationWithContext mocks base method. -func (m *MockEC2) ReplaceRouteTableAssociationWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteTableAssociationInput, arg2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceRouteTableAssociationWithContext indicates an expected call of ReplaceRouteTableAssociationWithContext. -func (mr *MockEC2MockRecorder) ReplaceRouteTableAssociationWithContext(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, "ReplaceRouteTableAssociationWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceRouteTableAssociationWithContext), varargs...) -} - -// ReplaceRouteWithContext mocks base method. -func (m *MockEC2) ReplaceRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...request.Option) (*ec2.ReplaceRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceRouteWithContext indicates an expected call of ReplaceRouteWithContext. -func (mr *MockEC2MockRecorder) ReplaceRouteWithContext(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, "ReplaceRouteWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceRouteWithContext), varargs...) -} - -// ReplaceTransitGatewayRoute mocks base method. -func (m *MockEC2) ReplaceTransitGatewayRoute(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceTransitGatewayRoute", arg0) - ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceTransitGatewayRoute indicates an expected call of ReplaceTransitGatewayRoute. -func (mr *MockEC2MockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2)(nil).ReplaceTransitGatewayRoute), arg0) -} - -// ReplaceTransitGatewayRouteRequest mocks base method. -func (m *MockEC2) ReplaceTransitGatewayRouteRequest(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReplaceTransitGatewayRouteOutput) - return ret0, ret1 -} - -// ReplaceTransitGatewayRouteRequest indicates an expected call of ReplaceTransitGatewayRouteRequest. -func (mr *MockEC2MockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceTransitGatewayRouteRequest), arg0) -} - -// ReplaceTransitGatewayRouteWithContext mocks base method. -func (m *MockEC2) ReplaceTransitGatewayRouteWithContext(arg0 context.Context, arg1 *ec2.ReplaceTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReplaceTransitGatewayRouteWithContext indicates an expected call of ReplaceTransitGatewayRouteWithContext. -func (mr *MockEC2MockRecorder) ReplaceTransitGatewayRouteWithContext(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, "ReplaceTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2)(nil).ReplaceTransitGatewayRouteWithContext), varargs...) -} - -// ReplaceVpnTunnel mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ReplaceVpnTunnel(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnel", reflect.TypeOf((*MockEC2)(nil).ReplaceVpnTunnel), arg0) -} - -// ReplaceVpnTunnelRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ReplaceVpnTunnelRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceVpnTunnelRequest", reflect.TypeOf((*MockEC2)(nil).ReplaceVpnTunnelRequest), arg0) -} - -// ReplaceVpnTunnelWithContext mocks base method. -func (m *MockEC2) ReplaceVpnTunnelWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).ReplaceVpnTunnelWithContext), varargs...) -} - -// ReportInstanceStatus mocks base method. -func (m *MockEC2) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReportInstanceStatus", arg0) - ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReportInstanceStatus indicates an expected call of ReportInstanceStatus. -func (mr *MockEC2MockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2)(nil).ReportInstanceStatus), arg0) -} - -// ReportInstanceStatusRequest mocks base method. -func (m *MockEC2) ReportInstanceStatusRequest(arg0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReportInstanceStatusRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ReportInstanceStatusOutput) - return ret0, ret1 -} - -// ReportInstanceStatusRequest indicates an expected call of ReportInstanceStatusRequest. -func (mr *MockEC2MockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2)(nil).ReportInstanceStatusRequest), arg0) -} - -// ReportInstanceStatusWithContext mocks base method. -func (m *MockEC2) ReportInstanceStatusWithContext(arg0 context.Context, arg1 *ec2.ReportInstanceStatusInput, arg2 ...request.Option) (*ec2.ReportInstanceStatusOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ReportInstanceStatusWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ReportInstanceStatusWithContext indicates an expected call of ReportInstanceStatusWithContext. -func (mr *MockEC2MockRecorder) ReportInstanceStatusWithContext(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, "ReportInstanceStatusWithContext", reflect.TypeOf((*MockEC2)(nil).ReportInstanceStatusWithContext), varargs...) -} - -// RequestSpotFleet mocks base method. -func (m *MockEC2) RequestSpotFleet(arg0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RequestSpotFleet", arg0) - ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RequestSpotFleet indicates an expected call of RequestSpotFleet. -func (mr *MockEC2MockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2)(nil).RequestSpotFleet), arg0) -} - -// RequestSpotFleetRequest mocks base method. -func (m *MockEC2) RequestSpotFleetRequest(arg0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RequestSpotFleetRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RequestSpotFleetOutput) - return ret0, ret1 -} - -// RequestSpotFleetRequest indicates an expected call of RequestSpotFleetRequest. -func (mr *MockEC2MockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2)(nil).RequestSpotFleetRequest), arg0) -} - -// RequestSpotFleetWithContext mocks base method. -func (m *MockEC2) RequestSpotFleetWithContext(arg0 context.Context, arg1 *ec2.RequestSpotFleetInput, arg2 ...request.Option) (*ec2.RequestSpotFleetOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RequestSpotFleetWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RequestSpotFleetWithContext indicates an expected call of RequestSpotFleetWithContext. -func (mr *MockEC2MockRecorder) RequestSpotFleetWithContext(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, "RequestSpotFleetWithContext", reflect.TypeOf((*MockEC2)(nil).RequestSpotFleetWithContext), varargs...) -} - -// RequestSpotInstances mocks base method. -func (m *MockEC2) RequestSpotInstances(arg0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RequestSpotInstances", arg0) - ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RequestSpotInstances indicates an expected call of RequestSpotInstances. -func (mr *MockEC2MockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2)(nil).RequestSpotInstances), arg0) -} - -// RequestSpotInstancesRequest mocks base method. -func (m *MockEC2) RequestSpotInstancesRequest(arg0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RequestSpotInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RequestSpotInstancesOutput) - return ret0, ret1 -} - -// RequestSpotInstancesRequest indicates an expected call of RequestSpotInstancesRequest. -func (mr *MockEC2MockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2)(nil).RequestSpotInstancesRequest), arg0) -} - -// RequestSpotInstancesWithContext mocks base method. -func (m *MockEC2) RequestSpotInstancesWithContext(arg0 context.Context, arg1 *ec2.RequestSpotInstancesInput, arg2 ...request.Option) (*ec2.RequestSpotInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RequestSpotInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RequestSpotInstancesWithContext indicates an expected call of RequestSpotInstancesWithContext. -func (mr *MockEC2MockRecorder) RequestSpotInstancesWithContext(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, "RequestSpotInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).RequestSpotInstancesWithContext), varargs...) -} - -// ResetAddressAttribute mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ResetAddressAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttribute", reflect.TypeOf((*MockEC2)(nil).ResetAddressAttribute), arg0) -} - -// ResetAddressAttributeRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) ResetAddressAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetAddressAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetAddressAttributeRequest), arg0) -} - -// ResetAddressAttributeWithContext mocks base method. -func (m *MockEC2) ResetAddressAttributeWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).ResetAddressAttributeWithContext), varargs...) -} - -// ResetEbsDefaultKmsKeyId mocks base method. -func (m *MockEC2) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyId", arg0) - ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetEbsDefaultKmsKeyId indicates an expected call of ResetEbsDefaultKmsKeyId. -func (mr *MockEC2MockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2)(nil).ResetEbsDefaultKmsKeyId), arg0) -} - -// ResetEbsDefaultKmsKeyIdRequest mocks base method. -func (m *MockEC2) ResetEbsDefaultKmsKeyIdRequest(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetEbsDefaultKmsKeyIdOutput) - return ret0, ret1 -} - -// ResetEbsDefaultKmsKeyIdRequest indicates an expected call of ResetEbsDefaultKmsKeyIdRequest. -func (mr *MockEC2MockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0) -} - -// ResetEbsDefaultKmsKeyIdWithContext mocks base method. -func (m *MockEC2) ResetEbsDefaultKmsKeyIdWithContext(arg0 context.Context, arg1 *ec2.ResetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetEbsDefaultKmsKeyIdWithContext indicates an expected call of ResetEbsDefaultKmsKeyIdWithContext. -func (mr *MockEC2MockRecorder) ResetEbsDefaultKmsKeyIdWithContext(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, "ResetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2)(nil).ResetEbsDefaultKmsKeyIdWithContext), varargs...) -} - -// ResetFpgaImageAttribute mocks base method. -func (m *MockEC2) ResetFpgaImageAttribute(arg0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetFpgaImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetFpgaImageAttribute indicates an expected call of ResetFpgaImageAttribute. -func (mr *MockEC2MockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2)(nil).ResetFpgaImageAttribute), arg0) -} - -// ResetFpgaImageAttributeRequest mocks base method. -func (m *MockEC2) ResetFpgaImageAttributeRequest(arg0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetFpgaImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetFpgaImageAttributeOutput) - return ret0, ret1 -} - -// ResetFpgaImageAttributeRequest indicates an expected call of ResetFpgaImageAttributeRequest. -func (mr *MockEC2MockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetFpgaImageAttributeRequest), arg0) -} - -// ResetFpgaImageAttributeWithContext mocks base method. -func (m *MockEC2) ResetFpgaImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetFpgaImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetFpgaImageAttributeWithContext indicates an expected call of ResetFpgaImageAttributeWithContext. -func (mr *MockEC2MockRecorder) ResetFpgaImageAttributeWithContext(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, "ResetFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ResetFpgaImageAttributeWithContext), varargs...) -} - -// ResetImageAttribute mocks base method. -func (m *MockEC2) ResetImageAttribute(arg0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetImageAttribute", arg0) - ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetImageAttribute indicates an expected call of ResetImageAttribute. -func (mr *MockEC2MockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2)(nil).ResetImageAttribute), arg0) -} - -// ResetImageAttributeRequest mocks base method. -func (m *MockEC2) ResetImageAttributeRequest(arg0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetImageAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetImageAttributeOutput) - return ret0, ret1 -} - -// ResetImageAttributeRequest indicates an expected call of ResetImageAttributeRequest. -func (mr *MockEC2MockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetImageAttributeRequest), arg0) -} - -// ResetImageAttributeWithContext mocks base method. -func (m *MockEC2) ResetImageAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetImageAttributeInput, arg2 ...request.Option) (*ec2.ResetImageAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetImageAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetImageAttributeWithContext indicates an expected call of ResetImageAttributeWithContext. -func (mr *MockEC2MockRecorder) ResetImageAttributeWithContext(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, "ResetImageAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ResetImageAttributeWithContext), varargs...) -} - -// ResetInstanceAttribute mocks base method. -func (m *MockEC2) ResetInstanceAttribute(arg0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetInstanceAttribute", arg0) - ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetInstanceAttribute indicates an expected call of ResetInstanceAttribute. -func (mr *MockEC2MockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2)(nil).ResetInstanceAttribute), arg0) -} - -// ResetInstanceAttributeRequest mocks base method. -func (m *MockEC2) ResetInstanceAttributeRequest(arg0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetInstanceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetInstanceAttributeOutput) - return ret0, ret1 -} - -// ResetInstanceAttributeRequest indicates an expected call of ResetInstanceAttributeRequest. -func (mr *MockEC2MockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetInstanceAttributeRequest), arg0) -} - -// ResetInstanceAttributeWithContext mocks base method. -func (m *MockEC2) ResetInstanceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetInstanceAttributeInput, arg2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetInstanceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetInstanceAttributeWithContext indicates an expected call of ResetInstanceAttributeWithContext. -func (mr *MockEC2MockRecorder) ResetInstanceAttributeWithContext(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, "ResetInstanceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ResetInstanceAttributeWithContext), varargs...) -} - -// ResetNetworkInterfaceAttribute mocks base method. -func (m *MockEC2) ResetNetworkInterfaceAttribute(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttribute", arg0) - ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetNetworkInterfaceAttribute indicates an expected call of ResetNetworkInterfaceAttribute. -func (mr *MockEC2MockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2)(nil).ResetNetworkInterfaceAttribute), arg0) -} - -// ResetNetworkInterfaceAttributeRequest mocks base method. -func (m *MockEC2) ResetNetworkInterfaceAttributeRequest(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetNetworkInterfaceAttributeOutput) - return ret0, ret1 -} - -// ResetNetworkInterfaceAttributeRequest indicates an expected call of ResetNetworkInterfaceAttributeRequest. -func (mr *MockEC2MockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetNetworkInterfaceAttributeRequest), arg0) -} - -// ResetNetworkInterfaceAttributeWithContext mocks base method. -func (m *MockEC2) ResetNetworkInterfaceAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetNetworkInterfaceAttributeWithContext indicates an expected call of ResetNetworkInterfaceAttributeWithContext. -func (mr *MockEC2MockRecorder) ResetNetworkInterfaceAttributeWithContext(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, "ResetNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ResetNetworkInterfaceAttributeWithContext), varargs...) -} - -// ResetSnapshotAttribute mocks base method. -func (m *MockEC2) ResetSnapshotAttribute(arg0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetSnapshotAttribute", arg0) - ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetSnapshotAttribute indicates an expected call of ResetSnapshotAttribute. -func (mr *MockEC2MockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2)(nil).ResetSnapshotAttribute), arg0) -} - -// ResetSnapshotAttributeRequest mocks base method. -func (m *MockEC2) ResetSnapshotAttributeRequest(arg0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ResetSnapshotAttributeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.ResetSnapshotAttributeOutput) - return ret0, ret1 -} - -// ResetSnapshotAttributeRequest indicates an expected call of ResetSnapshotAttributeRequest. -func (mr *MockEC2MockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2)(nil).ResetSnapshotAttributeRequest), arg0) -} - -// ResetSnapshotAttributeWithContext mocks base method. -func (m *MockEC2) ResetSnapshotAttributeWithContext(arg0 context.Context, arg1 *ec2.ResetSnapshotAttributeInput, arg2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ResetSnapshotAttributeWithContext", varargs...) - ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ResetSnapshotAttributeWithContext indicates an expected call of ResetSnapshotAttributeWithContext. -func (mr *MockEC2MockRecorder) ResetSnapshotAttributeWithContext(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, "ResetSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2)(nil).ResetSnapshotAttributeWithContext), varargs...) -} - -// RestoreAddressToClassic mocks base method. -func (m *MockEC2) RestoreAddressToClassic(arg0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreAddressToClassic", arg0) - ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreAddressToClassic indicates an expected call of RestoreAddressToClassic. -func (mr *MockEC2MockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2)(nil).RestoreAddressToClassic), arg0) -} - -// RestoreAddressToClassicRequest mocks base method. -func (m *MockEC2) RestoreAddressToClassicRequest(arg0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreAddressToClassicRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RestoreAddressToClassicOutput) - return ret0, ret1 -} - -// RestoreAddressToClassicRequest indicates an expected call of RestoreAddressToClassicRequest. -func (mr *MockEC2MockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2)(nil).RestoreAddressToClassicRequest), arg0) -} - -// RestoreAddressToClassicWithContext mocks base method. -func (m *MockEC2) RestoreAddressToClassicWithContext(arg0 context.Context, arg1 *ec2.RestoreAddressToClassicInput, arg2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreAddressToClassicWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreAddressToClassicWithContext indicates an expected call of RestoreAddressToClassicWithContext. -func (mr *MockEC2MockRecorder) RestoreAddressToClassicWithContext(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, "RestoreAddressToClassicWithContext", reflect.TypeOf((*MockEC2)(nil).RestoreAddressToClassicWithContext), varargs...) -} - -// RestoreImageFromRecycleBin mocks base method. -func (m *MockEC2) RestoreImageFromRecycleBin(arg0 *ec2.RestoreImageFromRecycleBinInput) (*ec2.RestoreImageFromRecycleBinOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreImageFromRecycleBin", arg0) - ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreImageFromRecycleBin indicates an expected call of RestoreImageFromRecycleBin. -func (mr *MockEC2MockRecorder) RestoreImageFromRecycleBin(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBin", reflect.TypeOf((*MockEC2)(nil).RestoreImageFromRecycleBin), arg0) -} - -// RestoreImageFromRecycleBinRequest mocks base method. -func (m *MockEC2) RestoreImageFromRecycleBinRequest(arg0 *ec2.RestoreImageFromRecycleBinInput) (*request.Request, *ec2.RestoreImageFromRecycleBinOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RestoreImageFromRecycleBinOutput) - return ret0, ret1 -} - -// RestoreImageFromRecycleBinRequest indicates an expected call of RestoreImageFromRecycleBinRequest. -func (mr *MockEC2MockRecorder) RestoreImageFromRecycleBinRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreImageFromRecycleBinRequest", reflect.TypeOf((*MockEC2)(nil).RestoreImageFromRecycleBinRequest), arg0) -} - -// RestoreImageFromRecycleBinWithContext mocks base method. -func (m *MockEC2) RestoreImageFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreImageFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreImageFromRecycleBinOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreImageFromRecycleBinWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RestoreImageFromRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreImageFromRecycleBinWithContext indicates an expected call of RestoreImageFromRecycleBinWithContext. -func (mr *MockEC2MockRecorder) RestoreImageFromRecycleBinWithContext(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, "RestoreImageFromRecycleBinWithContext", reflect.TypeOf((*MockEC2)(nil).RestoreImageFromRecycleBinWithContext), varargs...) -} - -// RestoreManagedPrefixListVersion mocks base method. -func (m *MockEC2) RestoreManagedPrefixListVersion(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*ec2.RestoreManagedPrefixListVersionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersion", arg0) - ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreManagedPrefixListVersion indicates an expected call of RestoreManagedPrefixListVersion. -func (mr *MockEC2MockRecorder) RestoreManagedPrefixListVersion(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersion", reflect.TypeOf((*MockEC2)(nil).RestoreManagedPrefixListVersion), arg0) -} - -// RestoreManagedPrefixListVersionRequest mocks base method. -func (m *MockEC2) RestoreManagedPrefixListVersionRequest(arg0 *ec2.RestoreManagedPrefixListVersionInput) (*request.Request, *ec2.RestoreManagedPrefixListVersionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RestoreManagedPrefixListVersionOutput) - return ret0, ret1 -} - -// RestoreManagedPrefixListVersionRequest indicates an expected call of RestoreManagedPrefixListVersionRequest. -func (mr *MockEC2MockRecorder) RestoreManagedPrefixListVersionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreManagedPrefixListVersionRequest", reflect.TypeOf((*MockEC2)(nil).RestoreManagedPrefixListVersionRequest), arg0) -} - -// RestoreManagedPrefixListVersionWithContext mocks base method. -func (m *MockEC2) RestoreManagedPrefixListVersionWithContext(arg0 context.Context, arg1 *ec2.RestoreManagedPrefixListVersionInput, arg2 ...request.Option) (*ec2.RestoreManagedPrefixListVersionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreManagedPrefixListVersionWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RestoreManagedPrefixListVersionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreManagedPrefixListVersionWithContext indicates an expected call of RestoreManagedPrefixListVersionWithContext. -func (mr *MockEC2MockRecorder) RestoreManagedPrefixListVersionWithContext(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, "RestoreManagedPrefixListVersionWithContext", reflect.TypeOf((*MockEC2)(nil).RestoreManagedPrefixListVersionWithContext), varargs...) -} - -// RestoreSnapshotFromRecycleBin mocks base method. -func (m *MockEC2) RestoreSnapshotFromRecycleBin(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBin", arg0) - ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSnapshotFromRecycleBin indicates an expected call of RestoreSnapshotFromRecycleBin. -func (mr *MockEC2MockRecorder) RestoreSnapshotFromRecycleBin(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBin", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotFromRecycleBin), arg0) -} - -// RestoreSnapshotFromRecycleBinRequest mocks base method. -func (m *MockEC2) RestoreSnapshotFromRecycleBinRequest(arg0 *ec2.RestoreSnapshotFromRecycleBinInput) (*request.Request, *ec2.RestoreSnapshotFromRecycleBinOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RestoreSnapshotFromRecycleBinOutput) - return ret0, ret1 -} - -// RestoreSnapshotFromRecycleBinRequest indicates an expected call of RestoreSnapshotFromRecycleBinRequest. -func (mr *MockEC2MockRecorder) RestoreSnapshotFromRecycleBinRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotFromRecycleBinRequest", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotFromRecycleBinRequest), arg0) -} - -// RestoreSnapshotFromRecycleBinWithContext mocks base method. -func (m *MockEC2) RestoreSnapshotFromRecycleBinWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotFromRecycleBinInput, arg2 ...request.Option) (*ec2.RestoreSnapshotFromRecycleBinOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreSnapshotFromRecycleBinWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RestoreSnapshotFromRecycleBinOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSnapshotFromRecycleBinWithContext indicates an expected call of RestoreSnapshotFromRecycleBinWithContext. -func (mr *MockEC2MockRecorder) RestoreSnapshotFromRecycleBinWithContext(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, "RestoreSnapshotFromRecycleBinWithContext", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotFromRecycleBinWithContext), varargs...) -} - -// RestoreSnapshotTier mocks base method. -func (m *MockEC2) RestoreSnapshotTier(arg0 *ec2.RestoreSnapshotTierInput) (*ec2.RestoreSnapshotTierOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSnapshotTier", arg0) - ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSnapshotTier indicates an expected call of RestoreSnapshotTier. -func (mr *MockEC2MockRecorder) RestoreSnapshotTier(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTier", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotTier), arg0) -} - -// RestoreSnapshotTierRequest mocks base method. -func (m *MockEC2) RestoreSnapshotTierRequest(arg0 *ec2.RestoreSnapshotTierInput) (*request.Request, *ec2.RestoreSnapshotTierOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RestoreSnapshotTierRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RestoreSnapshotTierOutput) - return ret0, ret1 -} - -// RestoreSnapshotTierRequest indicates an expected call of RestoreSnapshotTierRequest. -func (mr *MockEC2MockRecorder) RestoreSnapshotTierRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreSnapshotTierRequest", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotTierRequest), arg0) -} - -// RestoreSnapshotTierWithContext mocks base method. -func (m *MockEC2) RestoreSnapshotTierWithContext(arg0 context.Context, arg1 *ec2.RestoreSnapshotTierInput, arg2 ...request.Option) (*ec2.RestoreSnapshotTierOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RestoreSnapshotTierWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RestoreSnapshotTierOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RestoreSnapshotTierWithContext indicates an expected call of RestoreSnapshotTierWithContext. -func (mr *MockEC2MockRecorder) RestoreSnapshotTierWithContext(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, "RestoreSnapshotTierWithContext", reflect.TypeOf((*MockEC2)(nil).RestoreSnapshotTierWithContext), varargs...) -} - -// RevokeClientVpnIngress mocks base method. -func (m *MockEC2) RevokeClientVpnIngress(arg0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeClientVpnIngress", arg0) - ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeClientVpnIngress indicates an expected call of RevokeClientVpnIngress. -func (mr *MockEC2MockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2)(nil).RevokeClientVpnIngress), arg0) -} - -// RevokeClientVpnIngressRequest mocks base method. -func (m *MockEC2) RevokeClientVpnIngressRequest(arg0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeClientVpnIngressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RevokeClientVpnIngressOutput) - return ret0, ret1 -} - -// RevokeClientVpnIngressRequest indicates an expected call of RevokeClientVpnIngressRequest. -func (mr *MockEC2MockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2)(nil).RevokeClientVpnIngressRequest), arg0) -} - -// RevokeClientVpnIngressWithContext mocks base method. -func (m *MockEC2) RevokeClientVpnIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeClientVpnIngressInput, arg2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RevokeClientVpnIngressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeClientVpnIngressWithContext indicates an expected call of RevokeClientVpnIngressWithContext. -func (mr *MockEC2MockRecorder) RevokeClientVpnIngressWithContext(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, "RevokeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2)(nil).RevokeClientVpnIngressWithContext), varargs...) -} - -// RevokeSecurityGroupEgress mocks base method. -func (m *MockEC2) RevokeSecurityGroupEgress(arg0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0) - ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupEgress), arg0) -} - -// RevokeSecurityGroupEgressRequest mocks base method. -func (m *MockEC2) RevokeSecurityGroupEgressRequest(arg0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RevokeSecurityGroupEgressOutput) - return ret0, ret1 -} - -// RevokeSecurityGroupEgressRequest indicates an expected call of RevokeSecurityGroupEgressRequest. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupEgressRequest), arg0) -} - -// RevokeSecurityGroupEgressWithContext mocks base method. -func (m *MockEC2) RevokeSecurityGroupEgressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeSecurityGroupEgressWithContext indicates an expected call of RevokeSecurityGroupEgressWithContext. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupEgressWithContext(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, "RevokeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupEgressWithContext), varargs...) -} - -// RevokeSecurityGroupIngress mocks base method. -func (m *MockEC2) RevokeSecurityGroupIngress(arg0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", arg0) - ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupIngress), arg0) -} - -// RevokeSecurityGroupIngressRequest mocks base method. -func (m *MockEC2) RevokeSecurityGroupIngressRequest(arg0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RevokeSecurityGroupIngressOutput) - return ret0, ret1 -} - -// RevokeSecurityGroupIngressRequest indicates an expected call of RevokeSecurityGroupIngressRequest. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupIngressRequest), arg0) -} - -// RevokeSecurityGroupIngressWithContext mocks base method. -func (m *MockEC2) RevokeSecurityGroupIngressWithContext(arg0 context.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RevokeSecurityGroupIngressWithContext indicates an expected call of RevokeSecurityGroupIngressWithContext. -func (mr *MockEC2MockRecorder) RevokeSecurityGroupIngressWithContext(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, "RevokeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupIngressWithContext), varargs...) -} - -// RunInstances mocks base method. -func (m *MockEC2) RunInstances(arg0 *ec2.RunInstancesInput) (*ec2.Reservation, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunInstances", arg0) - ret0, _ := ret[0].(*ec2.Reservation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RunInstances indicates an expected call of RunInstances. -func (mr *MockEC2MockRecorder) RunInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2)(nil).RunInstances), arg0) -} - -// RunInstancesRequest mocks base method. -func (m *MockEC2) RunInstancesRequest(arg0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.Reservation) - return ret0, ret1 -} - -// RunInstancesRequest indicates an expected call of RunInstancesRequest. -func (mr *MockEC2MockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2)(nil).RunInstancesRequest), arg0) -} - -// RunInstancesWithContext mocks base method. -func (m *MockEC2) RunInstancesWithContext(arg0 context.Context, arg1 *ec2.RunInstancesInput, arg2 ...request.Option) (*ec2.Reservation, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RunInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.Reservation) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RunInstancesWithContext indicates an expected call of RunInstancesWithContext. -func (mr *MockEC2MockRecorder) RunInstancesWithContext(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, "RunInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).RunInstancesWithContext), varargs...) -} - -// RunScheduledInstances mocks base method. -func (m *MockEC2) RunScheduledInstances(arg0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunScheduledInstances", arg0) - ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RunScheduledInstances indicates an expected call of RunScheduledInstances. -func (mr *MockEC2MockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2)(nil).RunScheduledInstances), arg0) -} - -// RunScheduledInstancesRequest mocks base method. -func (m *MockEC2) RunScheduledInstancesRequest(arg0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RunScheduledInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.RunScheduledInstancesOutput) - return ret0, ret1 -} - -// RunScheduledInstancesRequest indicates an expected call of RunScheduledInstancesRequest. -func (mr *MockEC2MockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2)(nil).RunScheduledInstancesRequest), arg0) -} - -// RunScheduledInstancesWithContext mocks base method. -func (m *MockEC2) RunScheduledInstancesWithContext(arg0 context.Context, arg1 *ec2.RunScheduledInstancesInput, arg2 ...request.Option) (*ec2.RunScheduledInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RunScheduledInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RunScheduledInstancesWithContext indicates an expected call of RunScheduledInstancesWithContext. -func (mr *MockEC2MockRecorder) RunScheduledInstancesWithContext(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, "RunScheduledInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).RunScheduledInstancesWithContext), varargs...) -} - -// SearchLocalGatewayRoutes mocks base method. -func (m *MockEC2) SearchLocalGatewayRoutes(arg0 *ec2.SearchLocalGatewayRoutesInput) (*ec2.SearchLocalGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchLocalGatewayRoutes", arg0) - ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchLocalGatewayRoutes indicates an expected call of SearchLocalGatewayRoutes. -func (mr *MockEC2MockRecorder) SearchLocalGatewayRoutes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutes", reflect.TypeOf((*MockEC2)(nil).SearchLocalGatewayRoutes), arg0) -} - -// SearchLocalGatewayRoutesPages mocks base method. -func (m *MockEC2) SearchLocalGatewayRoutesPages(arg0 *ec2.SearchLocalGatewayRoutesInput, arg1 func(*ec2.SearchLocalGatewayRoutesOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// SearchLocalGatewayRoutesPages indicates an expected call of SearchLocalGatewayRoutesPages. -func (mr *MockEC2MockRecorder) SearchLocalGatewayRoutesPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPages", reflect.TypeOf((*MockEC2)(nil).SearchLocalGatewayRoutesPages), arg0, arg1) -} - -// SearchLocalGatewayRoutesPagesWithContext mocks base method. -func (m *MockEC2) SearchLocalGatewayRoutesPagesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 func(*ec2.SearchLocalGatewayRoutesOutput, 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, "SearchLocalGatewayRoutesPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// SearchLocalGatewayRoutesPagesWithContext indicates an expected call of SearchLocalGatewayRoutesPagesWithContext. -func (mr *MockEC2MockRecorder) SearchLocalGatewayRoutesPagesWithContext(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, "SearchLocalGatewayRoutesPagesWithContext", reflect.TypeOf((*MockEC2)(nil).SearchLocalGatewayRoutesPagesWithContext), varargs...) -} - -// SearchLocalGatewayRoutesRequest mocks base method. -func (m *MockEC2) SearchLocalGatewayRoutesRequest(arg0 *ec2.SearchLocalGatewayRoutesInput) (*request.Request, *ec2.SearchLocalGatewayRoutesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.SearchLocalGatewayRoutesOutput) - return ret0, ret1 -} - -// SearchLocalGatewayRoutesRequest indicates an expected call of SearchLocalGatewayRoutesRequest. -func (mr *MockEC2MockRecorder) SearchLocalGatewayRoutesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesRequest", reflect.TypeOf((*MockEC2)(nil).SearchLocalGatewayRoutesRequest), arg0) -} - -// SearchLocalGatewayRoutesWithContext mocks base method. -func (m *MockEC2) SearchLocalGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchLocalGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchLocalGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SearchLocalGatewayRoutesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.SearchLocalGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchLocalGatewayRoutesWithContext indicates an expected call of SearchLocalGatewayRoutesWithContext. -func (mr *MockEC2MockRecorder) SearchLocalGatewayRoutesWithContext(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, "SearchLocalGatewayRoutesWithContext", reflect.TypeOf((*MockEC2)(nil).SearchLocalGatewayRoutesWithContext), varargs...) -} - -// SearchTransitGatewayMulticastGroups mocks base method. -func (m *MockEC2) SearchTransitGatewayMulticastGroups(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroups", arg0) - ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchTransitGatewayMulticastGroups indicates an expected call of SearchTransitGatewayMulticastGroups. -func (mr *MockEC2MockRecorder) SearchTransitGatewayMulticastGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroups", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayMulticastGroups), arg0) -} - -// SearchTransitGatewayMulticastGroupsPages mocks base method. -func (m *MockEC2) SearchTransitGatewayMulticastGroupsPages(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput, arg1 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// SearchTransitGatewayMulticastGroupsPages indicates an expected call of SearchTransitGatewayMulticastGroupsPages. -func (mr *MockEC2MockRecorder) SearchTransitGatewayMulticastGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPages", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayMulticastGroupsPages), arg0, arg1) -} - -// SearchTransitGatewayMulticastGroupsPagesWithContext mocks base method. -func (m *MockEC2) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 func(*ec2.SearchTransitGatewayMulticastGroupsOutput, 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, "SearchTransitGatewayMulticastGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// SearchTransitGatewayMulticastGroupsPagesWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsPagesWithContext. -func (mr *MockEC2MockRecorder) SearchTransitGatewayMulticastGroupsPagesWithContext(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, "SearchTransitGatewayMulticastGroupsPagesWithContext", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayMulticastGroupsPagesWithContext), varargs...) -} - -// SearchTransitGatewayMulticastGroupsRequest mocks base method. -func (m *MockEC2) SearchTransitGatewayMulticastGroupsRequest(arg0 *ec2.SearchTransitGatewayMulticastGroupsInput) (*request.Request, *ec2.SearchTransitGatewayMulticastGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.SearchTransitGatewayMulticastGroupsOutput) - return ret0, ret1 -} - -// SearchTransitGatewayMulticastGroupsRequest indicates an expected call of SearchTransitGatewayMulticastGroupsRequest. -func (mr *MockEC2MockRecorder) SearchTransitGatewayMulticastGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsRequest", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayMulticastGroupsRequest), arg0) -} - -// SearchTransitGatewayMulticastGroupsWithContext mocks base method. -func (m *MockEC2) SearchTransitGatewayMulticastGroupsWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayMulticastGroupsInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayMulticastGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SearchTransitGatewayMulticastGroupsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.SearchTransitGatewayMulticastGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchTransitGatewayMulticastGroupsWithContext indicates an expected call of SearchTransitGatewayMulticastGroupsWithContext. -func (mr *MockEC2MockRecorder) SearchTransitGatewayMulticastGroupsWithContext(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, "SearchTransitGatewayMulticastGroupsWithContext", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayMulticastGroupsWithContext), varargs...) -} - -// SearchTransitGatewayRoutes mocks base method. -func (m *MockEC2) SearchTransitGatewayRoutes(arg0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchTransitGatewayRoutes", arg0) - ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchTransitGatewayRoutes indicates an expected call of SearchTransitGatewayRoutes. -func (mr *MockEC2MockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayRoutes), arg0) -} - -// SearchTransitGatewayRoutesRequest mocks base method. -func (m *MockEC2) SearchTransitGatewayRoutesRequest(arg0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.SearchTransitGatewayRoutesOutput) - return ret0, ret1 -} - -// SearchTransitGatewayRoutesRequest indicates an expected call of SearchTransitGatewayRoutesRequest. -func (mr *MockEC2MockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayRoutesRequest), arg0) -} - -// SearchTransitGatewayRoutesWithContext mocks base method. -func (m *MockEC2) SearchTransitGatewayRoutesWithContext(arg0 context.Context, arg1 *ec2.SearchTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SearchTransitGatewayRoutesWithContext indicates an expected call of SearchTransitGatewayRoutesWithContext. -func (mr *MockEC2MockRecorder) SearchTransitGatewayRoutesWithContext(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, "SearchTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2)(nil).SearchTransitGatewayRoutesWithContext), varargs...) -} - -// SendDiagnosticInterrupt mocks base method. -func (m *MockEC2) SendDiagnosticInterrupt(arg0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendDiagnosticInterrupt", arg0) - ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendDiagnosticInterrupt indicates an expected call of SendDiagnosticInterrupt. -func (mr *MockEC2MockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2)(nil).SendDiagnosticInterrupt), arg0) -} - -// SendDiagnosticInterruptRequest mocks base method. -func (m *MockEC2) SendDiagnosticInterruptRequest(arg0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SendDiagnosticInterruptRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.SendDiagnosticInterruptOutput) - return ret0, ret1 -} - -// SendDiagnosticInterruptRequest indicates an expected call of SendDiagnosticInterruptRequest. -func (mr *MockEC2MockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2)(nil).SendDiagnosticInterruptRequest), arg0) -} - -// SendDiagnosticInterruptWithContext mocks base method. -func (m *MockEC2) SendDiagnosticInterruptWithContext(arg0 context.Context, arg1 *ec2.SendDiagnosticInterruptInput, arg2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SendDiagnosticInterruptWithContext", varargs...) - ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SendDiagnosticInterruptWithContext indicates an expected call of SendDiagnosticInterruptWithContext. -func (mr *MockEC2MockRecorder) SendDiagnosticInterruptWithContext(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, "SendDiagnosticInterruptWithContext", reflect.TypeOf((*MockEC2)(nil).SendDiagnosticInterruptWithContext), varargs...) -} - -// StartInstances mocks base method. -func (m *MockEC2) StartInstances(arg0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartInstances", arg0) - ret0, _ := ret[0].(*ec2.StartInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartInstances indicates an expected call of StartInstances. -func (mr *MockEC2MockRecorder) StartInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2)(nil).StartInstances), arg0) -} - -// StartInstancesRequest mocks base method. -func (m *MockEC2) StartInstancesRequest(arg0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.StartInstancesOutput) - return ret0, ret1 -} - -// StartInstancesRequest indicates an expected call of StartInstancesRequest. -func (mr *MockEC2MockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2)(nil).StartInstancesRequest), arg0) -} - -// StartInstancesWithContext mocks base method. -func (m *MockEC2) StartInstancesWithContext(arg0 context.Context, arg1 *ec2.StartInstancesInput, arg2 ...request.Option) (*ec2.StartInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.StartInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartInstancesWithContext indicates an expected call of StartInstancesWithContext. -func (mr *MockEC2MockRecorder) StartInstancesWithContext(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, "StartInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).StartInstancesWithContext), varargs...) -} - -// StartNetworkInsightsAccessScopeAnalysis mocks base method. -func (m *MockEC2) StartNetworkInsightsAccessScopeAnalysis(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysis", arg0) - ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartNetworkInsightsAccessScopeAnalysis indicates an expected call of StartNetworkInsightsAccessScopeAnalysis. -func (mr *MockEC2MockRecorder) StartNetworkInsightsAccessScopeAnalysis(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysis", reflect.TypeOf((*MockEC2)(nil).StartNetworkInsightsAccessScopeAnalysis), arg0) -} - -// StartNetworkInsightsAccessScopeAnalysisRequest mocks base method. -func (m *MockEC2) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 *ec2.StartNetworkInsightsAccessScopeAnalysisInput) (*request.Request, *ec2.StartNetworkInsightsAccessScopeAnalysisOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput) - return ret0, ret1 -} - -// StartNetworkInsightsAccessScopeAnalysisRequest indicates an expected call of StartNetworkInsightsAccessScopeAnalysisRequest. -func (mr *MockEC2MockRecorder) StartNetworkInsightsAccessScopeAnalysisRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAccessScopeAnalysisRequest", reflect.TypeOf((*MockEC2)(nil).StartNetworkInsightsAccessScopeAnalysisRequest), arg0) -} - -// StartNetworkInsightsAccessScopeAnalysisWithContext mocks base method. -func (m *MockEC2) StartNetworkInsightsAccessScopeAnalysisWithContext(arg0 context.Context, arg1 *ec2.StartNetworkInsightsAccessScopeAnalysisInput, arg2 ...request.Option) (*ec2.StartNetworkInsightsAccessScopeAnalysisOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartNetworkInsightsAccessScopeAnalysisWithContext", varargs...) - ret0, _ := ret[0].(*ec2.StartNetworkInsightsAccessScopeAnalysisOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartNetworkInsightsAccessScopeAnalysisWithContext indicates an expected call of StartNetworkInsightsAccessScopeAnalysisWithContext. -func (mr *MockEC2MockRecorder) StartNetworkInsightsAccessScopeAnalysisWithContext(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, "StartNetworkInsightsAccessScopeAnalysisWithContext", reflect.TypeOf((*MockEC2)(nil).StartNetworkInsightsAccessScopeAnalysisWithContext), varargs...) -} - -// StartNetworkInsightsAnalysis mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) StartNetworkInsightsAnalysis(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysis", reflect.TypeOf((*MockEC2)(nil).StartNetworkInsightsAnalysis), arg0) -} - -// StartNetworkInsightsAnalysisRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) StartNetworkInsightsAnalysisRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartNetworkInsightsAnalysisRequest", reflect.TypeOf((*MockEC2)(nil).StartNetworkInsightsAnalysisRequest), arg0) -} - -// StartNetworkInsightsAnalysisWithContext mocks base method. -func (m *MockEC2) StartNetworkInsightsAnalysisWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).StartNetworkInsightsAnalysisWithContext), varargs...) -} - -// StartVpcEndpointServicePrivateDnsVerification mocks base method. -func (m *MockEC2) StartVpcEndpointServicePrivateDnsVerification(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerification", arg0) - ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartVpcEndpointServicePrivateDnsVerification indicates an expected call of StartVpcEndpointServicePrivateDnsVerification. -func (mr *MockEC2MockRecorder) StartVpcEndpointServicePrivateDnsVerification(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerification", reflect.TypeOf((*MockEC2)(nil).StartVpcEndpointServicePrivateDnsVerification), arg0) -} - -// StartVpcEndpointServicePrivateDnsVerificationRequest mocks base method. -func (m *MockEC2) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput) (*request.Request, *ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) - return ret0, ret1 -} - -// StartVpcEndpointServicePrivateDnsVerificationRequest indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationRequest. -func (mr *MockEC2MockRecorder) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationRequest", reflect.TypeOf((*MockEC2)(nil).StartVpcEndpointServicePrivateDnsVerificationRequest), arg0) -} - -// StartVpcEndpointServicePrivateDnsVerificationWithContext mocks base method. -func (m *MockEC2) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0 context.Context, arg1 *ec2.StartVpcEndpointServicePrivateDnsVerificationInput, arg2 ...request.Option) (*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StartVpcEndpointServicePrivateDnsVerificationWithContext", varargs...) - ret0, _ := ret[0].(*ec2.StartVpcEndpointServicePrivateDnsVerificationOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StartVpcEndpointServicePrivateDnsVerificationWithContext indicates an expected call of StartVpcEndpointServicePrivateDnsVerificationWithContext. -func (mr *MockEC2MockRecorder) StartVpcEndpointServicePrivateDnsVerificationWithContext(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, "StartVpcEndpointServicePrivateDnsVerificationWithContext", reflect.TypeOf((*MockEC2)(nil).StartVpcEndpointServicePrivateDnsVerificationWithContext), varargs...) -} - -// StopInstances mocks base method. -func (m *MockEC2) StopInstances(arg0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopInstances", arg0) - ret0, _ := ret[0].(*ec2.StopInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopInstances indicates an expected call of StopInstances. -func (mr *MockEC2MockRecorder) StopInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2)(nil).StopInstances), arg0) -} - -// StopInstancesRequest mocks base method. -func (m *MockEC2) StopInstancesRequest(arg0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "StopInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.StopInstancesOutput) - return ret0, ret1 -} - -// StopInstancesRequest indicates an expected call of StopInstancesRequest. -func (mr *MockEC2MockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2)(nil).StopInstancesRequest), arg0) -} - -// StopInstancesWithContext mocks base method. -func (m *MockEC2) StopInstancesWithContext(arg0 context.Context, arg1 *ec2.StopInstancesInput, arg2 ...request.Option) (*ec2.StopInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "StopInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.StopInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// StopInstancesWithContext indicates an expected call of StopInstancesWithContext. -func (mr *MockEC2MockRecorder) StopInstancesWithContext(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, "StopInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).StopInstancesWithContext), varargs...) -} - -// TerminateClientVpnConnections mocks base method. -func (m *MockEC2) TerminateClientVpnConnections(arg0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateClientVpnConnections", arg0) - ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateClientVpnConnections indicates an expected call of TerminateClientVpnConnections. -func (mr *MockEC2MockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2)(nil).TerminateClientVpnConnections), arg0) -} - -// TerminateClientVpnConnectionsRequest mocks base method. -func (m *MockEC2) TerminateClientVpnConnectionsRequest(arg0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.TerminateClientVpnConnectionsOutput) - return ret0, ret1 -} - -// TerminateClientVpnConnectionsRequest indicates an expected call of TerminateClientVpnConnectionsRequest. -func (mr *MockEC2MockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2)(nil).TerminateClientVpnConnectionsRequest), arg0) -} - -// TerminateClientVpnConnectionsWithContext mocks base method. -func (m *MockEC2) TerminateClientVpnConnectionsWithContext(arg0 context.Context, arg1 *ec2.TerminateClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsWithContext", varargs...) - ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateClientVpnConnectionsWithContext indicates an expected call of TerminateClientVpnConnectionsWithContext. -func (mr *MockEC2MockRecorder) TerminateClientVpnConnectionsWithContext(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, "TerminateClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2)(nil).TerminateClientVpnConnectionsWithContext), varargs...) -} - -// TerminateInstances mocks base method. -func (m *MockEC2) TerminateInstances(arg0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateInstances", arg0) - ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateInstances indicates an expected call of TerminateInstances. -func (mr *MockEC2MockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2)(nil).TerminateInstances), arg0) -} - -// TerminateInstancesRequest mocks base method. -func (m *MockEC2) TerminateInstancesRequest(arg0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TerminateInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.TerminateInstancesOutput) - return ret0, ret1 -} - -// TerminateInstancesRequest indicates an expected call of TerminateInstancesRequest. -func (mr *MockEC2MockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2)(nil).TerminateInstancesRequest), arg0) -} - -// TerminateInstancesWithContext mocks base method. -func (m *MockEC2) TerminateInstancesWithContext(arg0 context.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...request.Option) (*ec2.TerminateInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "TerminateInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TerminateInstancesWithContext indicates an expected call of TerminateInstancesWithContext. -func (mr *MockEC2MockRecorder) TerminateInstancesWithContext(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, "TerminateInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).TerminateInstancesWithContext), varargs...) -} - -// UnassignIpv6Addresses mocks base method. -func (m *MockEC2) UnassignIpv6Addresses(arg0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnassignIpv6Addresses", arg0) - ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnassignIpv6Addresses indicates an expected call of UnassignIpv6Addresses. -func (mr *MockEC2MockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2)(nil).UnassignIpv6Addresses), arg0) -} - -// UnassignIpv6AddressesRequest mocks base method. -func (m *MockEC2) UnassignIpv6AddressesRequest(arg0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnassignIpv6AddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UnassignIpv6AddressesOutput) - return ret0, ret1 -} - -// UnassignIpv6AddressesRequest indicates an expected call of UnassignIpv6AddressesRequest. -func (mr *MockEC2MockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2)(nil).UnassignIpv6AddressesRequest), arg0) -} - -// UnassignIpv6AddressesWithContext mocks base method. -func (m *MockEC2) UnassignIpv6AddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignIpv6AddressesInput, arg2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UnassignIpv6AddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnassignIpv6AddressesWithContext indicates an expected call of UnassignIpv6AddressesWithContext. -func (mr *MockEC2MockRecorder) UnassignIpv6AddressesWithContext(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, "UnassignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2)(nil).UnassignIpv6AddressesWithContext), varargs...) -} - -// UnassignPrivateIpAddresses mocks base method. -func (m *MockEC2) UnassignPrivateIpAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnassignPrivateIpAddresses", arg0) - ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnassignPrivateIpAddresses indicates an expected call of UnassignPrivateIpAddresses. -func (mr *MockEC2MockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2)(nil).UnassignPrivateIpAddresses), arg0) -} - -// UnassignPrivateIpAddressesRequest mocks base method. -func (m *MockEC2) UnassignPrivateIpAddressesRequest(arg0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UnassignPrivateIpAddressesOutput) - return ret0, ret1 -} - -// UnassignPrivateIpAddressesRequest indicates an expected call of UnassignPrivateIpAddressesRequest. -func (mr *MockEC2MockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2)(nil).UnassignPrivateIpAddressesRequest), arg0) -} - -// UnassignPrivateIpAddressesWithContext mocks base method. -func (m *MockEC2) UnassignPrivateIpAddressesWithContext(arg0 context.Context, arg1 *ec2.UnassignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnassignPrivateIpAddressesWithContext indicates an expected call of UnassignPrivateIpAddressesWithContext. -func (mr *MockEC2MockRecorder) UnassignPrivateIpAddressesWithContext(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, "UnassignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2)(nil).UnassignPrivateIpAddressesWithContext), varargs...) -} - -// UnassignPrivateNatGatewayAddress mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) UnassignPrivateNatGatewayAddress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddress", reflect.TypeOf((*MockEC2)(nil).UnassignPrivateNatGatewayAddress), arg0) -} - -// UnassignPrivateNatGatewayAddressRequest mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) UnassignPrivateNatGatewayAddressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateNatGatewayAddressRequest", reflect.TypeOf((*MockEC2)(nil).UnassignPrivateNatGatewayAddressRequest), arg0) -} - -// UnassignPrivateNatGatewayAddressWithContext mocks base method. -func (m *MockEC2) UnassignPrivateNatGatewayAddressWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).UnassignPrivateNatGatewayAddressWithContext), varargs...) -} - -// UnlockSnapshot mocks base method. -func (m *MockEC2) UnlockSnapshot(arg0 *ec2.UnlockSnapshotInput) (*ec2.UnlockSnapshotOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnlockSnapshot", arg0) - ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnlockSnapshot indicates an expected call of UnlockSnapshot. -func (mr *MockEC2MockRecorder) UnlockSnapshot(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshot", reflect.TypeOf((*MockEC2)(nil).UnlockSnapshot), arg0) -} - -// UnlockSnapshotRequest mocks base method. -func (m *MockEC2) UnlockSnapshotRequest(arg0 *ec2.UnlockSnapshotInput) (*request.Request, *ec2.UnlockSnapshotOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnlockSnapshotRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UnlockSnapshotOutput) - return ret0, ret1 -} - -// UnlockSnapshotRequest indicates an expected call of UnlockSnapshotRequest. -func (mr *MockEC2MockRecorder) UnlockSnapshotRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnlockSnapshotRequest", reflect.TypeOf((*MockEC2)(nil).UnlockSnapshotRequest), arg0) -} - -// UnlockSnapshotWithContext mocks base method. -func (m *MockEC2) UnlockSnapshotWithContext(arg0 context.Context, arg1 *ec2.UnlockSnapshotInput, arg2 ...request.Option) (*ec2.UnlockSnapshotOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UnlockSnapshotWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UnlockSnapshotOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnlockSnapshotWithContext indicates an expected call of UnlockSnapshotWithContext. -func (mr *MockEC2MockRecorder) UnlockSnapshotWithContext(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, "UnlockSnapshotWithContext", reflect.TypeOf((*MockEC2)(nil).UnlockSnapshotWithContext), varargs...) -} - -// UnmonitorInstances mocks base method. -func (m *MockEC2) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnmonitorInstances", arg0) - ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnmonitorInstances indicates an expected call of UnmonitorInstances. -func (mr *MockEC2MockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2)(nil).UnmonitorInstances), arg0) -} - -// UnmonitorInstancesRequest mocks base method. -func (m *MockEC2) UnmonitorInstancesRequest(arg0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UnmonitorInstancesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UnmonitorInstancesOutput) - return ret0, ret1 -} - -// UnmonitorInstancesRequest indicates an expected call of UnmonitorInstancesRequest. -func (mr *MockEC2MockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2)(nil).UnmonitorInstancesRequest), arg0) -} - -// UnmonitorInstancesWithContext mocks base method. -func (m *MockEC2) UnmonitorInstancesWithContext(arg0 context.Context, arg1 *ec2.UnmonitorInstancesInput, arg2 ...request.Option) (*ec2.UnmonitorInstancesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UnmonitorInstancesWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UnmonitorInstancesWithContext indicates an expected call of UnmonitorInstancesWithContext. -func (mr *MockEC2MockRecorder) UnmonitorInstancesWithContext(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, "UnmonitorInstancesWithContext", reflect.TypeOf((*MockEC2)(nil).UnmonitorInstancesWithContext), varargs...) -} - -// UpdateSecurityGroupRuleDescriptionsEgress mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsEgress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgress", arg0) - ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsEgress indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgress. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0) -} - -// UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsEgressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressRequest. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0) -} - -// UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsEgressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressWithContext. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsEgressWithContext(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, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsEgressWithContext), varargs...) -} - -// UpdateSecurityGroupRuleDescriptionsIngress mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsIngress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngress", arg0) - ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsIngress indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngress. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0) -} - -// UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsIngressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressRequest. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0) -} - -// UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method. -func (m *MockEC2) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 context.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", varargs...) - ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSecurityGroupRuleDescriptionsIngressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressWithContext. -func (mr *MockEC2MockRecorder) UpdateSecurityGroupRuleDescriptionsIngressWithContext(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, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", reflect.TypeOf((*MockEC2)(nil).UpdateSecurityGroupRuleDescriptionsIngressWithContext), varargs...) -} - -// WaitUntilBundleTaskComplete mocks base method. -func (m *MockEC2) WaitUntilBundleTaskComplete(arg0 *ec2.DescribeBundleTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilBundleTaskComplete", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilBundleTaskComplete indicates an expected call of WaitUntilBundleTaskComplete. -func (mr *MockEC2MockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2)(nil).WaitUntilBundleTaskComplete), arg0) -} - -// WaitUntilBundleTaskCompleteWithContext mocks base method. -func (m *MockEC2) WaitUntilBundleTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeBundleTasksInput, 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, "WaitUntilBundleTaskCompleteWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilBundleTaskCompleteWithContext indicates an expected call of WaitUntilBundleTaskCompleteWithContext. -func (mr *MockEC2MockRecorder) WaitUntilBundleTaskCompleteWithContext(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, "WaitUntilBundleTaskCompleteWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilBundleTaskCompleteWithContext), varargs...) -} - -// WaitUntilConversionTaskCancelled mocks base method. -func (m *MockEC2) WaitUntilConversionTaskCancelled(arg0 *ec2.DescribeConversionTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelled", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskCancelled indicates an expected call of WaitUntilConversionTaskCancelled. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskCancelled), arg0) -} - -// WaitUntilConversionTaskCancelledWithContext mocks base method. -func (m *MockEC2) WaitUntilConversionTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskCancelledWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskCancelledWithContext indicates an expected call of WaitUntilConversionTaskCancelledWithContext. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskCancelledWithContext(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, "WaitUntilConversionTaskCancelledWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskCancelledWithContext), varargs...) -} - -// WaitUntilConversionTaskCompleted mocks base method. -func (m *MockEC2) WaitUntilConversionTaskCompleted(arg0 *ec2.DescribeConversionTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskCompleted indicates an expected call of WaitUntilConversionTaskCompleted. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskCompleted), arg0) -} - -// WaitUntilConversionTaskCompletedWithContext mocks base method. -func (m *MockEC2) WaitUntilConversionTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskCompletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskCompletedWithContext indicates an expected call of WaitUntilConversionTaskCompletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskCompletedWithContext(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, "WaitUntilConversionTaskCompletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskCompletedWithContext), varargs...) -} - -// WaitUntilConversionTaskDeleted mocks base method. -func (m *MockEC2) WaitUntilConversionTaskDeleted(arg0 *ec2.DescribeConversionTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskDeleted indicates an expected call of WaitUntilConversionTaskDeleted. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskDeleted), arg0) -} - -// WaitUntilConversionTaskDeletedWithContext mocks base method. -func (m *MockEC2) WaitUntilConversionTaskDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeConversionTasksInput, 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, "WaitUntilConversionTaskDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilConversionTaskDeletedWithContext indicates an expected call of WaitUntilConversionTaskDeletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilConversionTaskDeletedWithContext(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, "WaitUntilConversionTaskDeletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilConversionTaskDeletedWithContext), varargs...) -} - -// WaitUntilCustomerGatewayAvailable mocks base method. -func (m *MockEC2) WaitUntilCustomerGatewayAvailable(arg0 *ec2.DescribeCustomerGatewaysInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilCustomerGatewayAvailable indicates an expected call of WaitUntilCustomerGatewayAvailable. -func (mr *MockEC2MockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilCustomerGatewayAvailable), arg0) -} - -// WaitUntilCustomerGatewayAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilCustomerGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeCustomerGatewaysInput, 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, "WaitUntilCustomerGatewayAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilCustomerGatewayAvailableWithContext indicates an expected call of WaitUntilCustomerGatewayAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilCustomerGatewayAvailableWithContext(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, "WaitUntilCustomerGatewayAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilCustomerGatewayAvailableWithContext), varargs...) -} - -// WaitUntilExportTaskCancelled mocks base method. -func (m *MockEC2) WaitUntilExportTaskCancelled(arg0 *ec2.DescribeExportTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelled", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilExportTaskCancelled indicates an expected call of WaitUntilExportTaskCancelled. -func (mr *MockEC2MockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2)(nil).WaitUntilExportTaskCancelled), arg0) -} - -// WaitUntilExportTaskCancelledWithContext mocks base method. -func (m *MockEC2) WaitUntilExportTaskCancelledWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, 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, "WaitUntilExportTaskCancelledWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilExportTaskCancelledWithContext indicates an expected call of WaitUntilExportTaskCancelledWithContext. -func (mr *MockEC2MockRecorder) WaitUntilExportTaskCancelledWithContext(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, "WaitUntilExportTaskCancelledWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilExportTaskCancelledWithContext), varargs...) -} - -// WaitUntilExportTaskCompleted mocks base method. -func (m *MockEC2) WaitUntilExportTaskCompleted(arg0 *ec2.DescribeExportTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilExportTaskCompleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilExportTaskCompleted indicates an expected call of WaitUntilExportTaskCompleted. -func (mr *MockEC2MockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilExportTaskCompleted), arg0) -} - -// WaitUntilExportTaskCompletedWithContext mocks base method. -func (m *MockEC2) WaitUntilExportTaskCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeExportTasksInput, 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, "WaitUntilExportTaskCompletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilExportTaskCompletedWithContext indicates an expected call of WaitUntilExportTaskCompletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilExportTaskCompletedWithContext(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, "WaitUntilExportTaskCompletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilExportTaskCompletedWithContext), varargs...) -} - -// WaitUntilImageAvailable mocks base method. -func (m *MockEC2) WaitUntilImageAvailable(arg0 *ec2.DescribeImagesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilImageAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilImageAvailable indicates an expected call of WaitUntilImageAvailable. -func (mr *MockEC2MockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilImageAvailable), arg0) -} - -// WaitUntilImageAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilImageAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, 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, "WaitUntilImageAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilImageAvailableWithContext indicates an expected call of WaitUntilImageAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilImageAvailableWithContext(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, "WaitUntilImageAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilImageAvailableWithContext), varargs...) -} - -// WaitUntilImageExists mocks base method. -func (m *MockEC2) WaitUntilImageExists(arg0 *ec2.DescribeImagesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilImageExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilImageExists indicates an expected call of WaitUntilImageExists. -func (mr *MockEC2MockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilImageExists), arg0) -} - -// WaitUntilImageExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilImageExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeImagesInput, 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, "WaitUntilImageExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilImageExistsWithContext indicates an expected call of WaitUntilImageExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilImageExistsWithContext(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, "WaitUntilImageExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilImageExistsWithContext), varargs...) -} - -// WaitUntilInstanceExists mocks base method. -func (m *MockEC2) WaitUntilInstanceExists(arg0 *ec2.DescribeInstancesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInstanceExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceExists indicates an expected call of WaitUntilInstanceExists. -func (mr *MockEC2MockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceExists), arg0) -} - -// WaitUntilInstanceExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilInstanceExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceExistsWithContext indicates an expected call of WaitUntilInstanceExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInstanceExistsWithContext(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, "WaitUntilInstanceExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceExistsWithContext), varargs...) -} - -// WaitUntilInstanceRunning mocks base method. -func (m *MockEC2) WaitUntilInstanceRunning(arg0 *ec2.DescribeInstancesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInstanceRunning", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceRunning indicates an expected call of WaitUntilInstanceRunning. -func (mr *MockEC2MockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceRunning), arg0) -} - -// WaitUntilInstanceRunningWithContext mocks base method. -func (m *MockEC2) WaitUntilInstanceRunningWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceRunningWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceRunningWithContext indicates an expected call of WaitUntilInstanceRunningWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInstanceRunningWithContext(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, "WaitUntilInstanceRunningWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceRunningWithContext), varargs...) -} - -// WaitUntilInstanceStatusOk mocks base method. -func (m *MockEC2) WaitUntilInstanceStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceStatusOk indicates an expected call of WaitUntilInstanceStatusOk. -func (mr *MockEC2MockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceStatusOk), arg0) -} - -// WaitUntilInstanceStatusOkWithContext mocks base method. -func (m *MockEC2) WaitUntilInstanceStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, 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, "WaitUntilInstanceStatusOkWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceStatusOkWithContext indicates an expected call of WaitUntilInstanceStatusOkWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInstanceStatusOkWithContext(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, "WaitUntilInstanceStatusOkWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceStatusOkWithContext), varargs...) -} - -// WaitUntilInstanceStopped mocks base method. -func (m *MockEC2) WaitUntilInstanceStopped(arg0 *ec2.DescribeInstancesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInstanceStopped", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceStopped indicates an expected call of WaitUntilInstanceStopped. -func (mr *MockEC2MockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceStopped), arg0) -} - -// WaitUntilInstanceStoppedWithContext mocks base method. -func (m *MockEC2) WaitUntilInstanceStoppedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceStoppedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceStoppedWithContext indicates an expected call of WaitUntilInstanceStoppedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInstanceStoppedWithContext(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, "WaitUntilInstanceStoppedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceStoppedWithContext), varargs...) -} - -// WaitUntilInstanceTerminated mocks base method. -func (m *MockEC2) WaitUntilInstanceTerminated(arg0 *ec2.DescribeInstancesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInstanceTerminated", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceTerminated indicates an expected call of WaitUntilInstanceTerminated. -func (mr *MockEC2MockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceTerminated), arg0) -} - -// WaitUntilInstanceTerminatedWithContext mocks base method. -func (m *MockEC2) WaitUntilInstanceTerminatedWithContext(arg0 context.Context, arg1 *ec2.DescribeInstancesInput, 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, "WaitUntilInstanceTerminatedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInstanceTerminatedWithContext indicates an expected call of WaitUntilInstanceTerminatedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInstanceTerminatedWithContext(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, "WaitUntilInstanceTerminatedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInstanceTerminatedWithContext), varargs...) -} - -// WaitUntilInternetGatewayExists mocks base method. -func (m *MockEC2) WaitUntilInternetGatewayExists(arg0 *ec2.DescribeInternetGatewaysInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilInternetGatewayExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInternetGatewayExists indicates an expected call of WaitUntilInternetGatewayExists. -func (mr *MockEC2MockRecorder) WaitUntilInternetGatewayExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInternetGatewayExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilInternetGatewayExists), arg0) -} - -// WaitUntilInternetGatewayExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilInternetGatewayExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeInternetGatewaysInput, 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, "WaitUntilInternetGatewayExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilInternetGatewayExistsWithContext indicates an expected call of WaitUntilInternetGatewayExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilInternetGatewayExistsWithContext(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, "WaitUntilInternetGatewayExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilInternetGatewayExistsWithContext), varargs...) -} - -// WaitUntilKeyPairExists mocks base method. -func (m *MockEC2) WaitUntilKeyPairExists(arg0 *ec2.DescribeKeyPairsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilKeyPairExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilKeyPairExists indicates an expected call of WaitUntilKeyPairExists. -func (mr *MockEC2MockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilKeyPairExists), arg0) -} - -// WaitUntilKeyPairExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilKeyPairExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeKeyPairsInput, 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, "WaitUntilKeyPairExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilKeyPairExistsWithContext indicates an expected call of WaitUntilKeyPairExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilKeyPairExistsWithContext(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, "WaitUntilKeyPairExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilKeyPairExistsWithContext), varargs...) -} - -// WaitUntilNatGatewayAvailable mocks base method. -func (m *MockEC2) WaitUntilNatGatewayAvailable(arg0 *ec2.DescribeNatGatewaysInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNatGatewayAvailable indicates an expected call of WaitUntilNatGatewayAvailable. -func (mr *MockEC2MockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilNatGatewayAvailable), arg0) -} - -// WaitUntilNatGatewayAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilNatGatewayAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, 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, "WaitUntilNatGatewayAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNatGatewayAvailableWithContext indicates an expected call of WaitUntilNatGatewayAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilNatGatewayAvailableWithContext(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, "WaitUntilNatGatewayAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilNatGatewayAvailableWithContext), varargs...) -} - -// WaitUntilNatGatewayDeleted mocks base method. -func (m *MockEC2) WaitUntilNatGatewayDeleted(arg0 *ec2.DescribeNatGatewaysInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilNatGatewayDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNatGatewayDeleted indicates an expected call of WaitUntilNatGatewayDeleted. -func (mr *MockEC2MockRecorder) WaitUntilNatGatewayDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayDeleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilNatGatewayDeleted), arg0) -} - -// WaitUntilNatGatewayDeletedWithContext mocks base method. -func (m *MockEC2) WaitUntilNatGatewayDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeNatGatewaysInput, 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, "WaitUntilNatGatewayDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNatGatewayDeletedWithContext indicates an expected call of WaitUntilNatGatewayDeletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilNatGatewayDeletedWithContext(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, "WaitUntilNatGatewayDeletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilNatGatewayDeletedWithContext), varargs...) -} - -// WaitUntilNetworkInterfaceAvailable mocks base method. -func (m *MockEC2) WaitUntilNetworkInterfaceAvailable(arg0 *ec2.DescribeNetworkInterfacesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNetworkInterfaceAvailable indicates an expected call of WaitUntilNetworkInterfaceAvailable. -func (mr *MockEC2MockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilNetworkInterfaceAvailable), arg0) -} - -// WaitUntilNetworkInterfaceAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilNetworkInterfaceAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeNetworkInterfacesInput, 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, "WaitUntilNetworkInterfaceAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilNetworkInterfaceAvailableWithContext indicates an expected call of WaitUntilNetworkInterfaceAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilNetworkInterfaceAvailableWithContext(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, "WaitUntilNetworkInterfaceAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilNetworkInterfaceAvailableWithContext), varargs...) -} - -// WaitUntilPasswordDataAvailable mocks base method. -func (m *MockEC2) WaitUntilPasswordDataAvailable(arg0 *ec2.GetPasswordDataInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilPasswordDataAvailable indicates an expected call of WaitUntilPasswordDataAvailable. -func (mr *MockEC2MockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilPasswordDataAvailable), arg0) -} - -// WaitUntilPasswordDataAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilPasswordDataAvailableWithContext(arg0 context.Context, arg1 *ec2.GetPasswordDataInput, 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, "WaitUntilPasswordDataAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilPasswordDataAvailableWithContext indicates an expected call of WaitUntilPasswordDataAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilPasswordDataAvailableWithContext(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, "WaitUntilPasswordDataAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilPasswordDataAvailableWithContext), varargs...) -} - -// WaitUntilSecurityGroupExists mocks base method. -func (m *MockEC2) WaitUntilSecurityGroupExists(arg0 *ec2.DescribeSecurityGroupsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilSecurityGroupExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSecurityGroupExists indicates an expected call of WaitUntilSecurityGroupExists. -func (mr *MockEC2MockRecorder) WaitUntilSecurityGroupExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilSecurityGroupExists), arg0) -} - -// WaitUntilSecurityGroupExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilSecurityGroupExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeSecurityGroupsInput, 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, "WaitUntilSecurityGroupExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSecurityGroupExistsWithContext indicates an expected call of WaitUntilSecurityGroupExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilSecurityGroupExistsWithContext(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, "WaitUntilSecurityGroupExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilSecurityGroupExistsWithContext), varargs...) -} - -// WaitUntilSnapshotCompleted mocks base method. -func (m *MockEC2) WaitUntilSnapshotCompleted(arg0 *ec2.DescribeSnapshotsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilSnapshotCompleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSnapshotCompleted indicates an expected call of WaitUntilSnapshotCompleted. -func (mr *MockEC2MockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilSnapshotCompleted), arg0) -} - -// WaitUntilSnapshotCompletedWithContext mocks base method. -func (m *MockEC2) WaitUntilSnapshotCompletedWithContext(arg0 context.Context, arg1 *ec2.DescribeSnapshotsInput, 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, "WaitUntilSnapshotCompletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSnapshotCompletedWithContext indicates an expected call of WaitUntilSnapshotCompletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilSnapshotCompletedWithContext(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, "WaitUntilSnapshotCompletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilSnapshotCompletedWithContext), varargs...) -} - -// WaitUntilSnapshotImported mocks base method. -func (m *MockEC2) 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 *MockEC2MockRecorder) WaitUntilSnapshotImported(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotImported", reflect.TypeOf((*MockEC2)(nil).WaitUntilSnapshotImported), arg0) -} - -// WaitUntilSnapshotImportedWithContext mocks base method. -func (m *MockEC2) WaitUntilSnapshotImportedWithContext(arg0 context.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 *MockEC2MockRecorder) 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((*MockEC2)(nil).WaitUntilSnapshotImportedWithContext), varargs...) -} - -// WaitUntilSpotInstanceRequestFulfilled mocks base method. -func (m *MockEC2) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilled", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSpotInstanceRequestFulfilled indicates an expected call of WaitUntilSpotInstanceRequestFulfilled. -func (mr *MockEC2MockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0) -} - -// WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method. -func (m *MockEC2) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 context.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, 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, "WaitUntilSpotInstanceRequestFulfilledWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSpotInstanceRequestFulfilledWithContext indicates an expected call of WaitUntilSpotInstanceRequestFulfilledWithContext. -func (mr *MockEC2MockRecorder) WaitUntilSpotInstanceRequestFulfilledWithContext(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, "WaitUntilSpotInstanceRequestFulfilledWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilSpotInstanceRequestFulfilledWithContext), varargs...) -} - -// WaitUntilStoreImageTaskComplete mocks base method. -func (m *MockEC2) WaitUntilStoreImageTaskComplete(arg0 *ec2.DescribeStoreImageTasksInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilStoreImageTaskComplete", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilStoreImageTaskComplete indicates an expected call of WaitUntilStoreImageTaskComplete. -func (mr *MockEC2MockRecorder) WaitUntilStoreImageTaskComplete(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilStoreImageTaskComplete", reflect.TypeOf((*MockEC2)(nil).WaitUntilStoreImageTaskComplete), arg0) -} - -// WaitUntilStoreImageTaskCompleteWithContext mocks base method. -func (m *MockEC2) WaitUntilStoreImageTaskCompleteWithContext(arg0 context.Context, arg1 *ec2.DescribeStoreImageTasksInput, 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, "WaitUntilStoreImageTaskCompleteWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilStoreImageTaskCompleteWithContext indicates an expected call of WaitUntilStoreImageTaskCompleteWithContext. -func (mr *MockEC2MockRecorder) WaitUntilStoreImageTaskCompleteWithContext(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, "WaitUntilStoreImageTaskCompleteWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilStoreImageTaskCompleteWithContext), varargs...) -} - -// WaitUntilSubnetAvailable mocks base method. -func (m *MockEC2) WaitUntilSubnetAvailable(arg0 *ec2.DescribeSubnetsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilSubnetAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSubnetAvailable indicates an expected call of WaitUntilSubnetAvailable. -func (mr *MockEC2MockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilSubnetAvailable), arg0) -} - -// WaitUntilSubnetAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilSubnetAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeSubnetsInput, 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, "WaitUntilSubnetAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSubnetAvailableWithContext indicates an expected call of WaitUntilSubnetAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilSubnetAvailableWithContext(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, "WaitUntilSubnetAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilSubnetAvailableWithContext), varargs...) -} - -// WaitUntilSystemStatusOk mocks base method. -func (m *MockEC2) WaitUntilSystemStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilSystemStatusOk", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSystemStatusOk indicates an expected call of WaitUntilSystemStatusOk. -func (mr *MockEC2MockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2)(nil).WaitUntilSystemStatusOk), arg0) -} - -// WaitUntilSystemStatusOkWithContext mocks base method. -func (m *MockEC2) WaitUntilSystemStatusOkWithContext(arg0 context.Context, arg1 *ec2.DescribeInstanceStatusInput, 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, "WaitUntilSystemStatusOkWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilSystemStatusOkWithContext indicates an expected call of WaitUntilSystemStatusOkWithContext. -func (mr *MockEC2MockRecorder) WaitUntilSystemStatusOkWithContext(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, "WaitUntilSystemStatusOkWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilSystemStatusOkWithContext), varargs...) -} - -// WaitUntilVolumeAvailable mocks base method. -func (m *MockEC2) WaitUntilVolumeAvailable(arg0 *ec2.DescribeVolumesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVolumeAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeAvailable indicates an expected call of WaitUntilVolumeAvailable. -func (mr *MockEC2MockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeAvailable), arg0) -} - -// WaitUntilVolumeAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilVolumeAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeAvailableWithContext indicates an expected call of WaitUntilVolumeAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVolumeAvailableWithContext(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, "WaitUntilVolumeAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeAvailableWithContext), varargs...) -} - -// WaitUntilVolumeDeleted mocks base method. -func (m *MockEC2) WaitUntilVolumeDeleted(arg0 *ec2.DescribeVolumesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVolumeDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeDeleted indicates an expected call of WaitUntilVolumeDeleted. -func (mr *MockEC2MockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeDeleted), arg0) -} - -// WaitUntilVolumeDeletedWithContext mocks base method. -func (m *MockEC2) WaitUntilVolumeDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeDeletedWithContext indicates an expected call of WaitUntilVolumeDeletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVolumeDeletedWithContext(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, "WaitUntilVolumeDeletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeDeletedWithContext), varargs...) -} - -// WaitUntilVolumeInUse mocks base method. -func (m *MockEC2) WaitUntilVolumeInUse(arg0 *ec2.DescribeVolumesInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVolumeInUse", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeInUse indicates an expected call of WaitUntilVolumeInUse. -func (mr *MockEC2MockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeInUse), arg0) -} - -// WaitUntilVolumeInUseWithContext mocks base method. -func (m *MockEC2) WaitUntilVolumeInUseWithContext(arg0 context.Context, arg1 *ec2.DescribeVolumesInput, 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, "WaitUntilVolumeInUseWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVolumeInUseWithContext indicates an expected call of WaitUntilVolumeInUseWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVolumeInUseWithContext(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, "WaitUntilVolumeInUseWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVolumeInUseWithContext), varargs...) -} - -// WaitUntilVpcAvailable mocks base method. -func (m *MockEC2) WaitUntilVpcAvailable(arg0 *ec2.DescribeVpcsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpcAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcAvailable indicates an expected call of WaitUntilVpcAvailable. -func (mr *MockEC2MockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcAvailable), arg0) -} - -// WaitUntilVpcAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilVpcAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, 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, "WaitUntilVpcAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcAvailableWithContext indicates an expected call of WaitUntilVpcAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpcAvailableWithContext(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, "WaitUntilVpcAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcAvailableWithContext), varargs...) -} - -// WaitUntilVpcExists mocks base method. -func (m *MockEC2) WaitUntilVpcExists(arg0 *ec2.DescribeVpcsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpcExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcExists indicates an expected call of WaitUntilVpcExists. -func (mr *MockEC2MockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcExists), arg0) -} - -// WaitUntilVpcExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilVpcExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcsInput, 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, "WaitUntilVpcExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcExistsWithContext indicates an expected call of WaitUntilVpcExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpcExistsWithContext(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, "WaitUntilVpcExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcExistsWithContext), varargs...) -} - -// WaitUntilVpcPeeringConnectionDeleted mocks base method. -func (m *MockEC2) WaitUntilVpcPeeringConnectionDeleted(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcPeeringConnectionDeleted indicates an expected call of WaitUntilVpcPeeringConnectionDeleted. -func (mr *MockEC2MockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0) -} - -// WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method. -func (m *MockEC2) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, 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, "WaitUntilVpcPeeringConnectionDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcPeeringConnectionDeletedWithContext indicates an expected call of WaitUntilVpcPeeringConnectionDeletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpcPeeringConnectionDeletedWithContext(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, "WaitUntilVpcPeeringConnectionDeletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcPeeringConnectionDeletedWithContext), varargs...) -} - -// WaitUntilVpcPeeringConnectionExists mocks base method. -func (m *MockEC2) WaitUntilVpcPeeringConnectionExists(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcPeeringConnectionExists indicates an expected call of WaitUntilVpcPeeringConnectionExists. -func (mr *MockEC2MockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcPeeringConnectionExists), arg0) -} - -// WaitUntilVpcPeeringConnectionExistsWithContext mocks base method. -func (m *MockEC2) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 context.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, 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, "WaitUntilVpcPeeringConnectionExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpcPeeringConnectionExistsWithContext indicates an expected call of WaitUntilVpcPeeringConnectionExistsWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpcPeeringConnectionExistsWithContext(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, "WaitUntilVpcPeeringConnectionExistsWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpcPeeringConnectionExistsWithContext), varargs...) -} - -// WaitUntilVpnConnectionAvailable mocks base method. -func (m *MockEC2) WaitUntilVpnConnectionAvailable(arg0 *ec2.DescribeVpnConnectionsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpnConnectionAvailable indicates an expected call of WaitUntilVpnConnectionAvailable. -func (mr *MockEC2MockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpnConnectionAvailable), arg0) -} - -// WaitUntilVpnConnectionAvailableWithContext mocks base method. -func (m *MockEC2) WaitUntilVpnConnectionAvailableWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, 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, "WaitUntilVpnConnectionAvailableWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpnConnectionAvailableWithContext indicates an expected call of WaitUntilVpnConnectionAvailableWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpnConnectionAvailableWithContext(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, "WaitUntilVpnConnectionAvailableWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...) -} - -// WaitUntilVpnConnectionDeleted mocks base method. -func (m *MockEC2) WaitUntilVpnConnectionDeleted(arg0 *ec2.DescribeVpnConnectionsInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpnConnectionDeleted indicates an expected call of WaitUntilVpnConnectionDeleted. -func (mr *MockEC2MockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpnConnectionDeleted), arg0) -} - -// WaitUntilVpnConnectionDeletedWithContext mocks base method. -func (m *MockEC2) WaitUntilVpnConnectionDeletedWithContext(arg0 context.Context, arg1 *ec2.DescribeVpnConnectionsInput, 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, "WaitUntilVpnConnectionDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilVpnConnectionDeletedWithContext indicates an expected call of WaitUntilVpnConnectionDeletedWithContext. -func (mr *MockEC2MockRecorder) WaitUntilVpnConnectionDeletedWithContext(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, "WaitUntilVpnConnectionDeletedWithContext", reflect.TypeOf((*MockEC2)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...) -} - -// WithdrawByoipCidr mocks base method. -func (m *MockEC2) WithdrawByoipCidr(arg0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WithdrawByoipCidr", arg0) - ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// WithdrawByoipCidr indicates an expected call of WithdrawByoipCidr. -func (mr *MockEC2MockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2)(nil).WithdrawByoipCidr), arg0) -} - -// WithdrawByoipCidrRequest mocks base method. -func (m *MockEC2) WithdrawByoipCidrRequest(arg0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WithdrawByoipCidrRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*ec2.WithdrawByoipCidrOutput) - return ret0, ret1 -} - -// WithdrawByoipCidrRequest indicates an expected call of WithdrawByoipCidrRequest. -func (mr *MockEC2MockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2)(nil).WithdrawByoipCidrRequest), arg0) -} - -// WithdrawByoipCidrWithContext mocks base method. -func (m *MockEC2) WithdrawByoipCidrWithContext(arg0 context.Context, arg1 *ec2.WithdrawByoipCidrInput, arg2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "WithdrawByoipCidrWithContext", varargs...) - ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// WithdrawByoipCidrWithContext indicates an expected call of WithdrawByoipCidrWithContext. -func (mr *MockEC2MockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// RevokeSecurityGroupIngressWithContext indicates an expected call of RevokeSecurityGroupIngressWithContext. +func (mr *MockEC2MockRecorder) RevokeSecurityGroupIngressWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2)(nil).WithdrawByoipCidrWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2)(nil).RevokeSecurityGroupIngressWithContext), arg0, arg1) } diff --git a/pkg/aws/services/elbv2.go b/pkg/aws/services/elbv2.go index 2d2b8d1fef..2532494cb8 100644 --- a/pkg/aws/services/elbv2.go +++ b/pkg/aws/services/elbv2.go @@ -2,106 +2,259 @@ package services import ( "context" - "github.com/aws/aws-sdk-go/aws/request" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/elbv2" - "github.com/aws/aws-sdk-go/service/elbv2/elbv2iface" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" + "time" ) type ELBV2 interface { - elbv2iface.ELBV2API - // wrapper to DescribeLoadBalancersPagesWithContext API, which aggregates paged results into list. - DescribeLoadBalancersAsList(ctx context.Context, input *elbv2.DescribeLoadBalancersInput) ([]*elbv2.LoadBalancer, error) + DescribeLoadBalancersAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) ([]types.LoadBalancer, error) // wrapper to DescribeTargetGroupsPagesWithContext API, which aggregates paged results into list. - DescribeTargetGroupsAsList(ctx context.Context, input *elbv2.DescribeTargetGroupsInput) ([]*elbv2.TargetGroup, error) + DescribeTargetGroupsAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupsInput) ([]types.TargetGroup, error) // wrapper to DescribeListenersPagesWithContext API, which aggregates paged results into list. - DescribeListenersAsList(ctx context.Context, input *elbv2.DescribeListenersInput) ([]*elbv2.Listener, error) + DescribeListenersAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeListenersInput) ([]types.Listener, error) + // TODO : Implement these when the API paginator is available // wrapper to DescribeListenerCertificatesWithContext API, which aggregates paged results into list. - DescribeListenerCertificatesAsList(ctx context.Context, input *elbv2.DescribeListenerCertificatesInput) ([]*elbv2.Certificate, error) + DescribeListenerCertificatesAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeListenerCertificatesInput) ([]types.Certificate, error) + // TODO : Implement these when the API paginator is available // wrapper to DescribeRulesWithContext API, which aggregates paged results into list. - DescribeRulesAsList(ctx context.Context, input *elbv2.DescribeRulesInput) ([]*elbv2.Rule, error) + DescribeRulesAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeRulesInput) ([]types.Rule, error) + + AddTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.AddTagsInput) (*elasticloadbalancingv2.AddTagsOutput, error) + RemoveTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.RemoveTagsInput) (*elasticloadbalancingv2.RemoveTagsOutput, error) + DescribeTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTagsInput) (*elasticloadbalancingv2.DescribeTagsOutput, error) + CreateListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateListenerInput) (*elasticloadbalancingv2.CreateListenerOutput, error) + DeleteListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteListenerInput) (*elasticloadbalancingv2.DeleteListenerOutput, error) + ModifyListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyListenerInput) (*elasticloadbalancingv2.ModifyListenerOutput, error) + ModifyLoadBalancerAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyLoadBalancerAttributesInput) (*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput, error) + DescribeLoadBalancerAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancerAttributesInput) (*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput, error) + CreateLoadBalancerWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateLoadBalancerInput) (*elasticloadbalancingv2.CreateLoadBalancerOutput, error) + DeleteLoadBalancerWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteLoadBalancerInput) (*elasticloadbalancingv2.DeleteLoadBalancerOutput, error) + SetIpAddressTypeWithContext(ctx context.Context, input *elasticloadbalancingv2.SetIpAddressTypeInput) (*elasticloadbalancingv2.SetIpAddressTypeOutput, error) + SetSubnetsWithContext(ctx context.Context, input *elasticloadbalancingv2.SetSubnetsInput) (*elasticloadbalancingv2.SetSubnetsOutput, error) + SetSecurityGroupsWithContext(ctx context.Context, input *elasticloadbalancingv2.SetSecurityGroupsInput) (*elasticloadbalancingv2.SetSecurityGroupsOutput, error) + ModifyTargetGroupAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyTargetGroupAttributesInput) (*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput, error) + DescribeTargetGroupAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupAttributesInput) (*elasticloadbalancingv2.DescribeTargetGroupAttributesOutput, error) + CreateTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateTargetGroupInput) (*elasticloadbalancingv2.CreateTargetGroupOutput, error) + ModifyTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyTargetGroupInput) (*elasticloadbalancingv2.ModifyTargetGroupOutput, error) + DeleteTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteTargetGroupInput) (*elasticloadbalancingv2.DeleteTargetGroupOutput, error) + DescribeTargetGroupsWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupsInput) (*elasticloadbalancingv2.DescribeTargetGroupsOutput, error) + DescribeTargetHealthWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetHealthInput) (*elasticloadbalancingv2.DescribeTargetHealthOutput, error) + DescribeLoadBalancersWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) (*elasticloadbalancingv2.DescribeLoadBalancersOutput, error) + WaitUntilLoadBalancerAvailableWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) error + DescribeListenersWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeListenersInput) (*elasticloadbalancingv2.DescribeListenersOutput, error) + DescribeRulesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeRulesInput) (*elasticloadbalancingv2.DescribeRulesOutput, error) + CreateRuleWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateRuleInput) (*elasticloadbalancingv2.CreateRuleOutput, error) + DeleteRuleWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteRuleInput) (*elasticloadbalancingv2.DeleteRuleOutput, error) + ModifyRuleWithContext(ctx context.Context, inout *elasticloadbalancingv2.ModifyRuleInput) (*elasticloadbalancingv2.ModifyRuleOutput, error) + RegisterTargetsWithContext(ctx context.Context, input *elasticloadbalancingv2.RegisterTargetsInput) (*elasticloadbalancingv2.RegisterTargetsOutput, error) + DeregisterTargetsWithContext(ctx context.Context, input *elasticloadbalancingv2.DeregisterTargetsInput) (*elasticloadbalancingv2.DeregisterTargetsOutput, error) + DescribeTrustStoresWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTrustStoresInput) (*elasticloadbalancingv2.DescribeTrustStoresOutput, error) + RemoveListenerCertificatesWithContext(ctx context.Context, input *elasticloadbalancingv2.RemoveListenerCertificatesInput) (*elasticloadbalancingv2.RemoveListenerCertificatesOutput, error) + AddListenerCertificatesWithContext(ctx context.Context, input *elasticloadbalancingv2.AddListenerCertificatesInput) (*elasticloadbalancingv2.AddListenerCertificatesOutput, error) } // NewELBV2 constructs new ELBV2 implementation. -func NewELBV2(session *session.Session) ELBV2 { - return &defaultELBV2{ - ELBV2API: elbv2.New(session), - } +// TODO custom resolver for gamma endpoint +func NewELBV2(cfg aws.Config) ELBV2 { + client := elasticloadbalancingv2.NewFromConfig(cfg) + return &elbv2Client{elbv2Client: client} } // default implementation for ELBV2. -type defaultELBV2 struct { - elbv2iface.ELBV2API +type elbv2Client struct { + elbv2Client *elasticloadbalancingv2.Client } -func (c *defaultELBV2) DescribeLoadBalancersAsList(ctx context.Context, input *elbv2.DescribeLoadBalancersInput) ([]*elbv2.LoadBalancer, error) { - var result []*elbv2.LoadBalancer - if err := c.DescribeLoadBalancersPagesWithContext(ctx, input, func(output *elbv2.DescribeLoadBalancersOutput, _ bool) bool { - result = append(result, output.LoadBalancers...) - return true - }); err != nil { +// TODO : Paginate this method once paginators are available +func (c *elbv2Client) DescribeListenerCertificatesAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeListenerCertificatesInput) ([]types.Certificate, error) { + output, err := c.elbv2Client.DescribeListenerCertificates(ctx, input) + if err != nil { return nil, err } - return result, nil + return output.Certificates, nil } -func (c *defaultELBV2) DescribeTargetGroupsAsList(ctx context.Context, input *elbv2.DescribeTargetGroupsInput) ([]*elbv2.TargetGroup, error) { - var result []*elbv2.TargetGroup - if err := c.DescribeTargetGroupsPagesWithContext(ctx, input, func(output *elbv2.DescribeTargetGroupsOutput, _ bool) bool { - result = append(result, output.TargetGroups...) - return true - }); err != nil { +// TODO : Paginate this method once paginators are available +func (c *elbv2Client) DescribeRulesAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeRulesInput) ([]types.Rule, error) { + output, err := c.elbv2Client.DescribeRules(ctx, input) + if err != nil { return nil, err } - return result, nil + return output.Rules, nil } -func (c *defaultELBV2) DescribeListenersAsList(ctx context.Context, input *elbv2.DescribeListenersInput) ([]*elbv2.Listener, error) { - var result []*elbv2.Listener - if err := c.DescribeListenersPagesWithContext(ctx, input, func(output *elbv2.DescribeListenersOutput, _ bool) bool { - result = append(result, output.Listeners...) - return true - }); err != nil { - return nil, err +func (c *elbv2Client) AddListenerCertificatesWithContext(ctx context.Context, input *elasticloadbalancingv2.AddListenerCertificatesInput) (*elasticloadbalancingv2.AddListenerCertificatesOutput, error) { + return c.elbv2Client.AddListenerCertificates(ctx, input) +} + +func (c *elbv2Client) RemoveListenerCertificatesWithContext(ctx context.Context, input *elasticloadbalancingv2.RemoveListenerCertificatesInput) (*elasticloadbalancingv2.RemoveListenerCertificatesOutput, error) { + return c.elbv2Client.RemoveListenerCertificates(ctx, input) +} + +func (c *elbv2Client) DescribeListenersWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeListenersInput) (*elasticloadbalancingv2.DescribeListenersOutput, error) { + return c.elbv2Client.DescribeListeners(ctx, input) +} + +func (c *elbv2Client) DescribeRulesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeRulesInput) (*elasticloadbalancingv2.DescribeRulesOutput, error) { + return c.elbv2Client.DescribeRules(ctx, input) +} + +func (c *elbv2Client) RegisterTargetsWithContext(ctx context.Context, input *elasticloadbalancingv2.RegisterTargetsInput) (*elasticloadbalancingv2.RegisterTargetsOutput, error) { + return c.elbv2Client.RegisterTargets(ctx, input) +} + +func (c *elbv2Client) DeregisterTargetsWithContext(ctx context.Context, input *elasticloadbalancingv2.DeregisterTargetsInput) (*elasticloadbalancingv2.DeregisterTargetsOutput, error) { + return c.elbv2Client.DeregisterTargets(ctx, input) +} + +func (c *elbv2Client) DescribeTrustStoresWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTrustStoresInput) (*elasticloadbalancingv2.DescribeTrustStoresOutput, error) { + return c.elbv2Client.DescribeTrustStores(ctx, input) +} + +func (c *elbv2Client) ModifyRuleWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyRuleInput) (*elasticloadbalancingv2.ModifyRuleOutput, error) { + return c.elbv2Client.ModifyRule(ctx, input) +} + +func (c *elbv2Client) DeleteRuleWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteRuleInput) (*elasticloadbalancingv2.DeleteRuleOutput, error) { + return c.elbv2Client.DeleteRule(ctx, input) +} + +func (c *elbv2Client) CreateRuleWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateRuleInput) (*elasticloadbalancingv2.CreateRuleOutput, error) { + return c.elbv2Client.CreateRule(ctx, input) +} + +func (c *elbv2Client) WaitUntilLoadBalancerAvailableWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) error { + waiter := elasticloadbalancingv2.NewLoadBalancerAvailableWaiter(c.elbv2Client) + err := waiter.Wait(ctx, input, 5*time.Minute) + return err +} + +func (c *elbv2Client) DescribeLoadBalancersWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) (*elasticloadbalancingv2.DescribeLoadBalancersOutput, error) { + return c.elbv2Client.DescribeLoadBalancers(ctx, input) +} + +func (c *elbv2Client) DescribeTargetHealthWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetHealthInput) (*elasticloadbalancingv2.DescribeTargetHealthOutput, error) { + return c.elbv2Client.DescribeTargetHealth(ctx, input) +} + +func (c *elbv2Client) DescribeTargetGroupsWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupsInput) (*elasticloadbalancingv2.DescribeTargetGroupsOutput, error) { + return c.elbv2Client.DescribeTargetGroups(ctx, input) +} + +func (c *elbv2Client) DeleteTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteTargetGroupInput) (*elasticloadbalancingv2.DeleteTargetGroupOutput, error) { + return c.elbv2Client.DeleteTargetGroup(ctx, input) +} + +func (c *elbv2Client) ModifyTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyTargetGroupInput) (*elasticloadbalancingv2.ModifyTargetGroupOutput, error) { + return c.elbv2Client.ModifyTargetGroup(ctx, input) +} + +func (c *elbv2Client) CreateTargetGroupWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateTargetGroupInput) (*elasticloadbalancingv2.CreateTargetGroupOutput, error) { + return c.elbv2Client.CreateTargetGroup(ctx, input) +} + +func (c *elbv2Client) DescribeTargetGroupAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupAttributesInput) (*elasticloadbalancingv2.DescribeTargetGroupAttributesOutput, error) { + return c.elbv2Client.DescribeTargetGroupAttributes(ctx, input) +} + +func (c *elbv2Client) ModifyTargetGroupAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyTargetGroupAttributesInput) (*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput, error) { + return c.elbv2Client.ModifyTargetGroupAttributes(ctx, input) +} + +func (c *elbv2Client) SetSecurityGroupsWithContext(ctx context.Context, input *elasticloadbalancingv2.SetSecurityGroupsInput) (*elasticloadbalancingv2.SetSecurityGroupsOutput, error) { + return c.elbv2Client.SetSecurityGroups(ctx, input) +} + +func (c *elbv2Client) SetSubnetsWithContext(ctx context.Context, input *elasticloadbalancingv2.SetSubnetsInput) (*elasticloadbalancingv2.SetSubnetsOutput, error) { + return c.elbv2Client.SetSubnets(ctx, input) +} + +func (c *elbv2Client) SetIpAddressTypeWithContext(ctx context.Context, input *elasticloadbalancingv2.SetIpAddressTypeInput) (*elasticloadbalancingv2.SetIpAddressTypeOutput, error) { + return c.elbv2Client.SetIpAddressType(ctx, input) +} + +func (c *elbv2Client) DeleteLoadBalancerWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteLoadBalancerInput) (*elasticloadbalancingv2.DeleteLoadBalancerOutput, error) { + return c.elbv2Client.DeleteLoadBalancer(ctx, input) +} + +func (c *elbv2Client) CreateLoadBalancerWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateLoadBalancerInput) (*elasticloadbalancingv2.CreateLoadBalancerOutput, error) { + return c.elbv2Client.CreateLoadBalancer(ctx, input) +} + +func (c *elbv2Client) DescribeLoadBalancerAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancerAttributesInput) (*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput, error) { + return c.elbv2Client.DescribeLoadBalancerAttributes(ctx, input) +} + +func (c *elbv2Client) ModifyLoadBalancerAttributesWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyLoadBalancerAttributesInput) (*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput, error) { + return c.elbv2Client.ModifyLoadBalancerAttributes(ctx, input) +} + +func (c *elbv2Client) ModifyListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.ModifyListenerInput) (*elasticloadbalancingv2.ModifyListenerOutput, error) { + return c.elbv2Client.ModifyListener(ctx, input) +} + +func (c *elbv2Client) DeleteListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.DeleteListenerInput) (*elasticloadbalancingv2.DeleteListenerOutput, error) { + return c.elbv2Client.DeleteListener(ctx, input) +} + +func (c *elbv2Client) CreateListenerWithContext(ctx context.Context, input *elasticloadbalancingv2.CreateListenerInput) (*elasticloadbalancingv2.CreateListenerOutput, error) { + return c.elbv2Client.CreateListener(ctx, input) +} + +func (c *elbv2Client) DescribeTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.DescribeTagsInput) (*elasticloadbalancingv2.DescribeTagsOutput, error) { + return c.elbv2Client.DescribeTags(ctx, input) +} + +func (c *elbv2Client) AddTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.AddTagsInput) (*elasticloadbalancingv2.AddTagsOutput, error) { + return c.elbv2Client.AddTags(ctx, input) +} + +func (c *elbv2Client) RemoveTagsWithContext(ctx context.Context, input *elasticloadbalancingv2.RemoveTagsInput) (*elasticloadbalancingv2.RemoveTagsOutput, error) { + return c.elbv2Client.RemoveTags(ctx, input) +} + +func (c *elbv2Client) DescribeLoadBalancersAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeLoadBalancersInput) ([]types.LoadBalancer, error) { + var result []types.LoadBalancer + paginator := elasticloadbalancingv2.NewDescribeLoadBalancersPaginator(c.elbv2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } + result = append(result, output.LoadBalancers...) } return result, nil } -func (c *defaultELBV2) DescribeListenerCertificatesAsList(ctx context.Context, input *elbv2.DescribeListenerCertificatesInput) ([]*elbv2.Certificate, error) { - var certificates []*elbv2.Certificate - p := request.Pagination{ - EndPageOnSameToken: true, - NewRequest: func() (*request.Request, error) { - req, _ := c.DescribeListenerCertificatesRequest(input) - req.SetContext(ctx) - return req, nil - }, - } - for p.Next() { - page := p.Page().(*elbv2.DescribeListenerCertificatesOutput) - certificates = append(certificates, page.Certificates...) - } - return certificates, p.Err() -} - -func (c *defaultELBV2) DescribeRulesAsList(ctx context.Context, input *elbv2.DescribeRulesInput) ([]*elbv2.Rule, error) { - var rules []*elbv2.Rule - p := request.Pagination{ - EndPageOnSameToken: true, - NewRequest: func() (*request.Request, error) { - req, _ := c.DescribeRulesRequest(input) - req.SetContext(ctx) - return req, nil - }, +func (c *elbv2Client) DescribeTargetGroupsAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeTargetGroupsInput) ([]types.TargetGroup, error) { + var result []types.TargetGroup + paginator := elasticloadbalancingv2.NewDescribeTargetGroupsPaginator(c.elbv2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } + result = append(result, output.TargetGroups...) } - for p.Next() { - page := p.Page().(*elbv2.DescribeRulesOutput) - rules = append(rules, page.Rules...) + return result, nil +} + +func (c *elbv2Client) DescribeListenersAsList(ctx context.Context, input *elasticloadbalancingv2.DescribeListenersInput) ([]types.Listener, error) { + var result []types.Listener + paginator := elasticloadbalancingv2.NewDescribeListenersPaginator(c.elbv2Client, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err + } + result = append(result, output.Listeners...) } - return rules, p.Err() + return result, nil } diff --git a/pkg/aws/services/elbv2_mocks.go b/pkg/aws/services/elbv2_mocks.go index 3a5478ccbd..c6bb0a55c9 100644 --- a/pkg/aws/services/elbv2_mocks.go +++ b/pkg/aws/services/elbv2_mocks.go @@ -8,8 +8,8 @@ import ( context "context" reflect "reflect" - request "github.com/aws/aws-sdk-go/aws/request" - elbv2 "github.com/aws/aws-sdk-go/service/elbv2" + elasticloadbalancingv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" gomock "github.com/golang/mock/gomock" ) @@ -36,2640 +36,556 @@ func (m *MockELBV2) EXPECT() *MockELBV2MockRecorder { return m.recorder } -// AddListenerCertificates mocks base method. -func (m *MockELBV2) AddListenerCertificates(arg0 *elbv2.AddListenerCertificatesInput) (*elbv2.AddListenerCertificatesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddListenerCertificates", arg0) - ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddListenerCertificates indicates an expected call of AddListenerCertificates. -func (mr *MockELBV2MockRecorder) AddListenerCertificates(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificates", reflect.TypeOf((*MockELBV2)(nil).AddListenerCertificates), arg0) -} - -// AddListenerCertificatesRequest mocks base method. -func (m *MockELBV2) AddListenerCertificatesRequest(arg0 *elbv2.AddListenerCertificatesInput) (*request.Request, *elbv2.AddListenerCertificatesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddListenerCertificatesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.AddListenerCertificatesOutput) - return ret0, ret1 -} - -// AddListenerCertificatesRequest indicates an expected call of AddListenerCertificatesRequest. -func (mr *MockELBV2MockRecorder) AddListenerCertificatesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesRequest", reflect.TypeOf((*MockELBV2)(nil).AddListenerCertificatesRequest), arg0) -} - // AddListenerCertificatesWithContext mocks base method. -func (m *MockELBV2) AddListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.AddListenerCertificatesInput, arg2 ...request.Option) (*elbv2.AddListenerCertificatesOutput, error) { +func (m *MockELBV2) AddListenerCertificatesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.AddListenerCertificatesInput) (*elasticloadbalancingv2.AddListenerCertificatesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AddListenerCertificatesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.AddListenerCertificatesOutput) + ret := m.ctrl.Call(m, "AddListenerCertificatesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.AddListenerCertificatesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AddListenerCertificatesWithContext indicates an expected call of AddListenerCertificatesWithContext. -func (mr *MockELBV2MockRecorder) AddListenerCertificatesWithContext(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, "AddListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2)(nil).AddListenerCertificatesWithContext), varargs...) -} - -// AddTags mocks base method. -func (m *MockELBV2) AddTags(arg0 *elbv2.AddTagsInput) (*elbv2.AddTagsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTags", arg0) - ret0, _ := ret[0].(*elbv2.AddTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddTags indicates an expected call of AddTags. -func (mr *MockELBV2MockRecorder) AddTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBV2)(nil).AddTags), arg0) -} - -// AddTagsRequest mocks base method. -func (m *MockELBV2) AddTagsRequest(arg0 *elbv2.AddTagsInput) (*request.Request, *elbv2.AddTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.AddTagsOutput) - return ret0, ret1 -} - -// AddTagsRequest indicates an expected call of AddTagsRequest. -func (mr *MockELBV2MockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) AddListenerCertificatesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBV2)(nil).AddTagsRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2)(nil).AddListenerCertificatesWithContext), arg0, arg1) } // AddTagsWithContext mocks base method. -func (m *MockELBV2) AddTagsWithContext(arg0 context.Context, arg1 *elbv2.AddTagsInput, arg2 ...request.Option) (*elbv2.AddTagsOutput, error) { +func (m *MockELBV2) AddTagsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.AddTagsInput) (*elasticloadbalancingv2.AddTagsOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AddTagsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.AddTagsOutput) + ret := m.ctrl.Call(m, "AddTagsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.AddTagsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AddTagsWithContext indicates an expected call of AddTagsWithContext. -func (mr *MockELBV2MockRecorder) AddTagsWithContext(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, "AddTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).AddTagsWithContext), varargs...) -} - -// AddTrustStoreRevocations mocks base method. -func (m *MockELBV2) AddTrustStoreRevocations(arg0 *elbv2.AddTrustStoreRevocationsInput) (*elbv2.AddTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTrustStoreRevocations", arg0) - ret0, _ := ret[0].(*elbv2.AddTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddTrustStoreRevocations indicates an expected call of AddTrustStoreRevocations. -func (mr *MockELBV2MockRecorder) AddTrustStoreRevocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTrustStoreRevocations", reflect.TypeOf((*MockELBV2)(nil).AddTrustStoreRevocations), arg0) -} - -// AddTrustStoreRevocationsRequest mocks base method. -func (m *MockELBV2) AddTrustStoreRevocationsRequest(arg0 *elbv2.AddTrustStoreRevocationsInput) (*request.Request, *elbv2.AddTrustStoreRevocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AddTrustStoreRevocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.AddTrustStoreRevocationsOutput) - return ret0, ret1 -} - -// AddTrustStoreRevocationsRequest indicates an expected call of AddTrustStoreRevocationsRequest. -func (mr *MockELBV2MockRecorder) AddTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2)(nil).AddTrustStoreRevocationsRequest), arg0) -} - -// AddTrustStoreRevocationsWithContext mocks base method. -func (m *MockELBV2) AddTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.AddTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.AddTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AddTrustStoreRevocationsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.AddTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AddTrustStoreRevocationsWithContext indicates an expected call of AddTrustStoreRevocationsWithContext. -func (mr *MockELBV2MockRecorder) AddTrustStoreRevocationsWithContext(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, "AddTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2)(nil).AddTrustStoreRevocationsWithContext), varargs...) -} - -// CreateListener mocks base method. -func (m *MockELBV2) CreateListener(arg0 *elbv2.CreateListenerInput) (*elbv2.CreateListenerOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateListener", arg0) - ret0, _ := ret[0].(*elbv2.CreateListenerOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateListener indicates an expected call of CreateListener. -func (mr *MockELBV2MockRecorder) CreateListener(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockELBV2)(nil).CreateListener), arg0) -} - -// CreateListenerRequest mocks base method. -func (m *MockELBV2) CreateListenerRequest(arg0 *elbv2.CreateListenerInput) (*request.Request, *elbv2.CreateListenerOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateListenerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.CreateListenerOutput) - return ret0, ret1 -} - -// CreateListenerRequest indicates an expected call of CreateListenerRequest. -func (mr *MockELBV2MockRecorder) CreateListenerRequest(arg0 interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) AddTagsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerRequest", reflect.TypeOf((*MockELBV2)(nil).CreateListenerRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).AddTagsWithContext), arg0, arg1) } // CreateListenerWithContext mocks base method. -func (m *MockELBV2) CreateListenerWithContext(arg0 context.Context, arg1 *elbv2.CreateListenerInput, arg2 ...request.Option) (*elbv2.CreateListenerOutput, error) { +func (m *MockELBV2) CreateListenerWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateListenerInput) (*elasticloadbalancingv2.CreateListenerOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateListenerWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.CreateListenerOutput) + ret := m.ctrl.Call(m, "CreateListenerWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.CreateListenerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateListenerWithContext indicates an expected call of CreateListenerWithContext. -func (mr *MockELBV2MockRecorder) CreateListenerWithContext(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, "CreateListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateListenerWithContext), varargs...) -} - -// CreateLoadBalancer mocks base method. -func (m *MockELBV2) CreateLoadBalancer(arg0 *elbv2.CreateLoadBalancerInput) (*elbv2.CreateLoadBalancerOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0) - ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateLoadBalancer indicates an expected call of CreateLoadBalancer. -func (mr *MockELBV2MockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBV2)(nil).CreateLoadBalancer), arg0) -} - -// CreateLoadBalancerRequest mocks base method. -func (m *MockELBV2) CreateLoadBalancerRequest(arg0 *elbv2.CreateLoadBalancerInput) (*request.Request, *elbv2.CreateLoadBalancerOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateLoadBalancerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.CreateLoadBalancerOutput) - return ret0, ret1 -} - -// CreateLoadBalancerRequest indicates an expected call of CreateLoadBalancerRequest. -func (mr *MockELBV2MockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) CreateListenerWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBV2)(nil).CreateLoadBalancerRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateListenerWithContext), arg0, arg1) } // CreateLoadBalancerWithContext mocks base method. -func (m *MockELBV2) CreateLoadBalancerWithContext(arg0 context.Context, arg1 *elbv2.CreateLoadBalancerInput, arg2 ...request.Option) (*elbv2.CreateLoadBalancerOutput, error) { +func (m *MockELBV2) CreateLoadBalancerWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateLoadBalancerInput) (*elasticloadbalancingv2.CreateLoadBalancerOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateLoadBalancerWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.CreateLoadBalancerOutput) + ret := m.ctrl.Call(m, "CreateLoadBalancerWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.CreateLoadBalancerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext. -func (mr *MockELBV2MockRecorder) CreateLoadBalancerWithContext(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, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateLoadBalancerWithContext), varargs...) -} - -// CreateRule mocks base method. -func (m *MockELBV2) CreateRule(arg0 *elbv2.CreateRuleInput) (*elbv2.CreateRuleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRule", arg0) - ret0, _ := ret[0].(*elbv2.CreateRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateRule indicates an expected call of CreateRule. -func (mr *MockELBV2MockRecorder) CreateRule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRule", reflect.TypeOf((*MockELBV2)(nil).CreateRule), arg0) -} - -// CreateRuleRequest mocks base method. -func (m *MockELBV2) CreateRuleRequest(arg0 *elbv2.CreateRuleInput) (*request.Request, *elbv2.CreateRuleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.CreateRuleOutput) - return ret0, ret1 -} - -// CreateRuleRequest indicates an expected call of CreateRuleRequest. -func (mr *MockELBV2MockRecorder) CreateRuleRequest(arg0 interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) CreateLoadBalancerWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleRequest", reflect.TypeOf((*MockELBV2)(nil).CreateRuleRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateLoadBalancerWithContext), arg0, arg1) } // CreateRuleWithContext mocks base method. -func (m *MockELBV2) CreateRuleWithContext(arg0 context.Context, arg1 *elbv2.CreateRuleInput, arg2 ...request.Option) (*elbv2.CreateRuleOutput, error) { +func (m *MockELBV2) CreateRuleWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateRuleInput) (*elasticloadbalancingv2.CreateRuleOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateRuleWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.CreateRuleOutput) + ret := m.ctrl.Call(m, "CreateRuleWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.CreateRuleOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateRuleWithContext indicates an expected call of CreateRuleWithContext. -func (mr *MockELBV2MockRecorder) CreateRuleWithContext(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, "CreateRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateRuleWithContext), varargs...) -} - -// CreateTargetGroup mocks base method. -func (m *MockELBV2) CreateTargetGroup(arg0 *elbv2.CreateTargetGroupInput) (*elbv2.CreateTargetGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTargetGroup", arg0) - ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateTargetGroup indicates an expected call of CreateTargetGroup. -func (mr *MockELBV2MockRecorder) CreateTargetGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockELBV2)(nil).CreateTargetGroup), arg0) -} - -// CreateTargetGroupRequest mocks base method. -func (m *MockELBV2) CreateTargetGroupRequest(arg0 *elbv2.CreateTargetGroupInput) (*request.Request, *elbv2.CreateTargetGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTargetGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.CreateTargetGroupOutput) - return ret0, ret1 -} - -// CreateTargetGroupRequest indicates an expected call of CreateTargetGroupRequest. -func (mr *MockELBV2MockRecorder) CreateTargetGroupRequest(arg0 interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) CreateRuleWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupRequest", reflect.TypeOf((*MockELBV2)(nil).CreateTargetGroupRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateRuleWithContext), arg0, arg1) } // CreateTargetGroupWithContext mocks base method. -func (m *MockELBV2) CreateTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.CreateTargetGroupInput, arg2 ...request.Option) (*elbv2.CreateTargetGroupOutput, error) { +func (m *MockELBV2) CreateTargetGroupWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.CreateTargetGroupInput) (*elasticloadbalancingv2.CreateTargetGroupOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTargetGroupWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.CreateTargetGroupOutput) + ret := m.ctrl.Call(m, "CreateTargetGroupWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.CreateTargetGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTargetGroupWithContext indicates an expected call of CreateTargetGroupWithContext. -func (mr *MockELBV2MockRecorder) CreateTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) CreateTargetGroupWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateTargetGroupWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateTargetGroupWithContext), arg0, arg1) } -// CreateTrustStore mocks base method. -func (m *MockELBV2) CreateTrustStore(arg0 *elbv2.CreateTrustStoreInput) (*elbv2.CreateTrustStoreOutput, error) { +// DeleteListenerWithContext mocks base method. +func (m *MockELBV2) DeleteListenerWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteListenerInput) (*elasticloadbalancingv2.DeleteListenerOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrustStore", arg0) - ret0, _ := ret[0].(*elbv2.CreateTrustStoreOutput) + ret := m.ctrl.Call(m, "DeleteListenerWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteListenerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTrustStore indicates an expected call of CreateTrustStore. -func (mr *MockELBV2MockRecorder) CreateTrustStore(arg0 interface{}) *gomock.Call { +// DeleteListenerWithContext indicates an expected call of DeleteListenerWithContext. +func (mr *MockELBV2MockRecorder) DeleteListenerWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrustStore", reflect.TypeOf((*MockELBV2)(nil).CreateTrustStore), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteListenerWithContext), arg0, arg1) } -// CreateTrustStoreRequest mocks base method. -func (m *MockELBV2) CreateTrustStoreRequest(arg0 *elbv2.CreateTrustStoreInput) (*request.Request, *elbv2.CreateTrustStoreOutput) { +// DeleteLoadBalancerWithContext mocks base method. +func (m *MockELBV2) DeleteLoadBalancerWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteLoadBalancerInput) (*elasticloadbalancingv2.DeleteLoadBalancerOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateTrustStoreRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.CreateTrustStoreOutput) + ret := m.ctrl.Call(m, "DeleteLoadBalancerWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteLoadBalancerOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTrustStoreRequest indicates an expected call of CreateTrustStoreRequest. -func (mr *MockELBV2MockRecorder) CreateTrustStoreRequest(arg0 interface{}) *gomock.Call { +// DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext. +func (mr *MockELBV2MockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrustStoreRequest", reflect.TypeOf((*MockELBV2)(nil).CreateTrustStoreRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteLoadBalancerWithContext), arg0, arg1) } -// CreateTrustStoreWithContext mocks base method. -func (m *MockELBV2) CreateTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.CreateTrustStoreInput, arg2 ...request.Option) (*elbv2.CreateTrustStoreOutput, error) { +// DeleteRuleWithContext mocks base method. +func (m *MockELBV2) DeleteRuleWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteRuleInput) (*elasticloadbalancingv2.DeleteRuleOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateTrustStoreWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.CreateTrustStoreOutput) + ret := m.ctrl.Call(m, "DeleteRuleWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteRuleOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// CreateTrustStoreWithContext indicates an expected call of CreateTrustStoreWithContext. -func (mr *MockELBV2MockRecorder) CreateTrustStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext. +func (mr *MockELBV2MockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrustStoreWithContext", reflect.TypeOf((*MockELBV2)(nil).CreateTrustStoreWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteRuleWithContext), arg0, arg1) } -// DeleteListener mocks base method. -func (m *MockELBV2) DeleteListener(arg0 *elbv2.DeleteListenerInput) (*elbv2.DeleteListenerOutput, error) { +// DeleteTargetGroupWithContext mocks base method. +func (m *MockELBV2) DeleteTargetGroupWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DeleteTargetGroupInput) (*elasticloadbalancingv2.DeleteTargetGroupOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteListener", arg0) - ret0, _ := ret[0].(*elbv2.DeleteListenerOutput) + ret := m.ctrl.Call(m, "DeleteTargetGroupWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DeleteTargetGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteListener indicates an expected call of DeleteListener. -func (mr *MockELBV2MockRecorder) DeleteListener(arg0 interface{}) *gomock.Call { +// DeleteTargetGroupWithContext indicates an expected call of DeleteTargetGroupWithContext. +func (mr *MockELBV2MockRecorder) DeleteTargetGroupWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListener", reflect.TypeOf((*MockELBV2)(nil).DeleteListener), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteTargetGroupWithContext), arg0, arg1) } -// DeleteListenerRequest mocks base method. -func (m *MockELBV2) DeleteListenerRequest(arg0 *elbv2.DeleteListenerInput) (*request.Request, *elbv2.DeleteListenerOutput) { +// DeregisterTargetsWithContext mocks base method. +func (m *MockELBV2) DeregisterTargetsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DeregisterTargetsInput) (*elasticloadbalancingv2.DeregisterTargetsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteListenerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeleteListenerOutput) + ret := m.ctrl.Call(m, "DeregisterTargetsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DeregisterTargetsOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteListenerRequest indicates an expected call of DeleteListenerRequest. -func (mr *MockELBV2MockRecorder) DeleteListenerRequest(arg0 interface{}) *gomock.Call { +// DeregisterTargetsWithContext indicates an expected call of DeregisterTargetsWithContext. +func (mr *MockELBV2MockRecorder) DeregisterTargetsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerRequest", reflect.TypeOf((*MockELBV2)(nil).DeleteListenerRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsWithContext", reflect.TypeOf((*MockELBV2)(nil).DeregisterTargetsWithContext), arg0, arg1) } -// DeleteListenerWithContext mocks base method. -func (m *MockELBV2) DeleteListenerWithContext(arg0 context.Context, arg1 *elbv2.DeleteListenerInput, arg2 ...request.Option) (*elbv2.DeleteListenerOutput, error) { +// DescribeListenerCertificatesAsList mocks base method. +func (m *MockELBV2) DescribeListenerCertificatesAsList(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeListenerCertificatesInput) ([]types.Certificate, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteListenerWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeleteListenerOutput) + ret := m.ctrl.Call(m, "DescribeListenerCertificatesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Certificate) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteListenerWithContext indicates an expected call of DeleteListenerWithContext. -func (mr *MockELBV2MockRecorder) DeleteListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeListenerCertificatesAsList indicates an expected call of DescribeListenerCertificatesAsList. +func (mr *MockELBV2MockRecorder) DescribeListenerCertificatesAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteListenerWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeListenerCertificatesAsList), arg0, arg1) } -// DeleteLoadBalancer mocks base method. -func (m *MockELBV2) DeleteLoadBalancer(arg0 *elbv2.DeleteLoadBalancerInput) (*elbv2.DeleteLoadBalancerOutput, error) { +// DescribeListenersAsList mocks base method. +func (m *MockELBV2) DescribeListenersAsList(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeListenersInput) ([]types.Listener, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0) - ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput) + ret := m.ctrl.Call(m, "DescribeListenersAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Listener) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer. -func (mr *MockELBV2MockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call { +// DescribeListenersAsList indicates an expected call of DescribeListenersAsList. +func (mr *MockELBV2MockRecorder) DescribeListenersAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBV2)(nil).DeleteLoadBalancer), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersAsList), arg0, arg1) } -// DeleteLoadBalancerRequest mocks base method. -func (m *MockELBV2) DeleteLoadBalancerRequest(arg0 *elbv2.DeleteLoadBalancerInput) (*request.Request, *elbv2.DeleteLoadBalancerOutput) { +// DescribeListenersWithContext mocks base method. +func (m *MockELBV2) DescribeListenersWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeListenersInput) (*elasticloadbalancingv2.DescribeListenersOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeleteLoadBalancerOutput) + ret := m.ctrl.Call(m, "DescribeListenersWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeListenersOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest. -func (mr *MockELBV2MockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call { +// DescribeListenersWithContext indicates an expected call of DescribeListenersWithContext. +func (mr *MockELBV2MockRecorder) DescribeListenersWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBV2)(nil).DeleteLoadBalancerRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersWithContext), arg0, arg1) } -// DeleteLoadBalancerWithContext mocks base method. -func (m *MockELBV2) DeleteLoadBalancerWithContext(arg0 context.Context, arg1 *elbv2.DeleteLoadBalancerInput, arg2 ...request.Option) (*elbv2.DeleteLoadBalancerOutput, error) { +// DescribeLoadBalancerAttributesWithContext mocks base method. +func (m *MockELBV2) DescribeLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancerAttributesInput) (*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteLoadBalancerWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput) + ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeLoadBalancerAttributesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext. -func (mr *MockELBV2MockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext. +func (mr *MockELBV2MockRecorder) DescribeLoadBalancerAttributesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteLoadBalancerWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancerAttributesWithContext), arg0, arg1) } -// DeleteRule mocks base method. -func (m *MockELBV2) DeleteRule(arg0 *elbv2.DeleteRuleInput) (*elbv2.DeleteRuleOutput, error) { +// DescribeLoadBalancersAsList mocks base method. +func (m *MockELBV2) DescribeLoadBalancersAsList(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput) ([]types.LoadBalancer, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRule", arg0) - ret0, _ := ret[0].(*elbv2.DeleteRuleOutput) + ret := m.ctrl.Call(m, "DescribeLoadBalancersAsList", arg0, arg1) + ret0, _ := ret[0].([]types.LoadBalancer) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteRule indicates an expected call of DeleteRule. -func (mr *MockELBV2MockRecorder) DeleteRule(arg0 interface{}) *gomock.Call { +// DescribeLoadBalancersAsList indicates an expected call of DescribeLoadBalancersAsList. +func (mr *MockELBV2MockRecorder) DescribeLoadBalancersAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockELBV2)(nil).DeleteRule), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersAsList), arg0, arg1) } -// DeleteRuleRequest mocks base method. -func (m *MockELBV2) DeleteRuleRequest(arg0 *elbv2.DeleteRuleInput) (*request.Request, *elbv2.DeleteRuleOutput) { +// DescribeLoadBalancersWithContext mocks base method. +func (m *MockELBV2) DescribeLoadBalancersWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput) (*elasticloadbalancingv2.DescribeLoadBalancersOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeleteRuleOutput) + ret := m.ctrl.Call(m, "DescribeLoadBalancersWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeLoadBalancersOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteRuleRequest indicates an expected call of DeleteRuleRequest. -func (mr *MockELBV2MockRecorder) DeleteRuleRequest(arg0 interface{}) *gomock.Call { +// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext. +func (mr *MockELBV2MockRecorder) DescribeLoadBalancersWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleRequest", reflect.TypeOf((*MockELBV2)(nil).DeleteRuleRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersWithContext), arg0, arg1) } -// DeleteRuleWithContext mocks base method. -func (m *MockELBV2) DeleteRuleWithContext(arg0 context.Context, arg1 *elbv2.DeleteRuleInput, arg2 ...request.Option) (*elbv2.DeleteRuleOutput, error) { +// DescribeRulesAsList mocks base method. +func (m *MockELBV2) DescribeRulesAsList(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeRulesInput) ([]types.Rule, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteRuleWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeleteRuleOutput) + ret := m.ctrl.Call(m, "DescribeRulesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.Rule) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext. -func (mr *MockELBV2MockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeRulesAsList indicates an expected call of DescribeRulesAsList. +func (mr *MockELBV2MockRecorder) DescribeRulesAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteRuleWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeRulesAsList), arg0, arg1) } -// DeleteTargetGroup mocks base method. -func (m *MockELBV2) DeleteTargetGroup(arg0 *elbv2.DeleteTargetGroupInput) (*elbv2.DeleteTargetGroupOutput, error) { +// DescribeRulesWithContext mocks base method. +func (m *MockELBV2) DescribeRulesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeRulesInput) (*elasticloadbalancingv2.DescribeRulesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTargetGroup", arg0) - ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput) + ret := m.ctrl.Call(m, "DescribeRulesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeRulesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTargetGroup indicates an expected call of DeleteTargetGroup. -func (mr *MockELBV2MockRecorder) DeleteTargetGroup(arg0 interface{}) *gomock.Call { +// DescribeRulesWithContext indicates an expected call of DescribeRulesWithContext. +func (mr *MockELBV2MockRecorder) DescribeRulesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroup", reflect.TypeOf((*MockELBV2)(nil).DeleteTargetGroup), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeRulesWithContext), arg0, arg1) } -// DeleteTargetGroupRequest mocks base method. -func (m *MockELBV2) DeleteTargetGroupRequest(arg0 *elbv2.DeleteTargetGroupInput) (*request.Request, *elbv2.DeleteTargetGroupOutput) { +// DescribeTagsWithContext mocks base method. +func (m *MockELBV2) DescribeTagsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTagsInput) (*elasticloadbalancingv2.DescribeTagsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTargetGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeleteTargetGroupOutput) + ret := m.ctrl.Call(m, "DescribeTagsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTagsOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTargetGroupRequest indicates an expected call of DeleteTargetGroupRequest. -func (mr *MockELBV2MockRecorder) DeleteTargetGroupRequest(arg0 interface{}) *gomock.Call { +// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext. +func (mr *MockELBV2MockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupRequest", reflect.TypeOf((*MockELBV2)(nil).DeleteTargetGroupRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTagsWithContext), arg0, arg1) } -// DeleteTargetGroupWithContext mocks base method. -func (m *MockELBV2) DeleteTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.DeleteTargetGroupInput, arg2 ...request.Option) (*elbv2.DeleteTargetGroupOutput, error) { +// DescribeTargetGroupAttributesWithContext mocks base method. +func (m *MockELBV2) DescribeTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetGroupAttributesInput) (*elasticloadbalancingv2.DescribeTargetGroupAttributesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTargetGroupWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput) + ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTargetGroupAttributesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTargetGroupWithContext indicates an expected call of DeleteTargetGroupWithContext. -func (mr *MockELBV2MockRecorder) DeleteTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeTargetGroupAttributesWithContext indicates an expected call of DescribeTargetGroupAttributesWithContext. +func (mr *MockELBV2MockRecorder) DescribeTargetGroupAttributesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteTargetGroupWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupAttributesWithContext), arg0, arg1) } -// DeleteTrustStore mocks base method. -func (m *MockELBV2) DeleteTrustStore(arg0 *elbv2.DeleteTrustStoreInput) (*elbv2.DeleteTrustStoreOutput, error) { +// DescribeTargetGroupsAsList mocks base method. +func (m *MockELBV2) DescribeTargetGroupsAsList(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetGroupsInput) ([]types.TargetGroup, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrustStore", arg0) - ret0, _ := ret[0].(*elbv2.DeleteTrustStoreOutput) + ret := m.ctrl.Call(m, "DescribeTargetGroupsAsList", arg0, arg1) + ret0, _ := ret[0].([]types.TargetGroup) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTrustStore indicates an expected call of DeleteTrustStore. -func (mr *MockELBV2MockRecorder) DeleteTrustStore(arg0 interface{}) *gomock.Call { +// DescribeTargetGroupsAsList indicates an expected call of DescribeTargetGroupsAsList. +func (mr *MockELBV2MockRecorder) DescribeTargetGroupsAsList(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrustStore", reflect.TypeOf((*MockELBV2)(nil).DeleteTrustStore), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsAsList), arg0, arg1) } -// DeleteTrustStoreRequest mocks base method. -func (m *MockELBV2) DeleteTrustStoreRequest(arg0 *elbv2.DeleteTrustStoreInput) (*request.Request, *elbv2.DeleteTrustStoreOutput) { +// DescribeTargetGroupsWithContext mocks base method. +func (m *MockELBV2) DescribeTargetGroupsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetGroupsInput) (*elasticloadbalancingv2.DescribeTargetGroupsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteTrustStoreRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeleteTrustStoreOutput) + ret := m.ctrl.Call(m, "DescribeTargetGroupsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTargetGroupsOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTrustStoreRequest indicates an expected call of DeleteTrustStoreRequest. -func (mr *MockELBV2MockRecorder) DeleteTrustStoreRequest(arg0 interface{}) *gomock.Call { +// DescribeTargetGroupsWithContext indicates an expected call of DescribeTargetGroupsWithContext. +func (mr *MockELBV2MockRecorder) DescribeTargetGroupsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrustStoreRequest", reflect.TypeOf((*MockELBV2)(nil).DeleteTrustStoreRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsWithContext), arg0, arg1) } -// DeleteTrustStoreWithContext mocks base method. -func (m *MockELBV2) DeleteTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.DeleteTrustStoreInput, arg2 ...request.Option) (*elbv2.DeleteTrustStoreOutput, error) { +// DescribeTargetHealthWithContext mocks base method. +func (m *MockELBV2) DescribeTargetHealthWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTargetHealthInput) (*elasticloadbalancingv2.DescribeTargetHealthOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteTrustStoreWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeleteTrustStoreOutput) + ret := m.ctrl.Call(m, "DescribeTargetHealthWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTargetHealthOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeleteTrustStoreWithContext indicates an expected call of DeleteTrustStoreWithContext. -func (mr *MockELBV2MockRecorder) DeleteTrustStoreWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeTargetHealthWithContext indicates an expected call of DescribeTargetHealthWithContext. +func (mr *MockELBV2MockRecorder) DescribeTargetHealthWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrustStoreWithContext", reflect.TypeOf((*MockELBV2)(nil).DeleteTrustStoreWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetHealthWithContext), arg0, arg1) } -// DeregisterTargets mocks base method. -func (m *MockELBV2) DeregisterTargets(arg0 *elbv2.DeregisterTargetsInput) (*elbv2.DeregisterTargetsOutput, error) { +// DescribeTrustStoresWithContext mocks base method. +func (m *MockELBV2) DescribeTrustStoresWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeTrustStoresInput) (*elasticloadbalancingv2.DescribeTrustStoresOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTargets", arg0) - ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput) + ret := m.ctrl.Call(m, "DescribeTrustStoresWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.DescribeTrustStoresOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeregisterTargets indicates an expected call of DeregisterTargets. -func (mr *MockELBV2MockRecorder) DeregisterTargets(arg0 interface{}) *gomock.Call { +// DescribeTrustStoresWithContext indicates an expected call of DescribeTrustStoresWithContext. +func (mr *MockELBV2MockRecorder) DescribeTrustStoresWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargets", reflect.TypeOf((*MockELBV2)(nil).DeregisterTargets), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoresWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoresWithContext), arg0, arg1) } -// DeregisterTargetsRequest mocks base method. -func (m *MockELBV2) DeregisterTargetsRequest(arg0 *elbv2.DeregisterTargetsInput) (*request.Request, *elbv2.DeregisterTargetsOutput) { +// ModifyListenerWithContext mocks base method. +func (m *MockELBV2) ModifyListenerWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyListenerInput) (*elasticloadbalancingv2.ModifyListenerOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeregisterTargetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DeregisterTargetsOutput) + ret := m.ctrl.Call(m, "ModifyListenerWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyListenerOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DeregisterTargetsRequest indicates an expected call of DeregisterTargetsRequest. -func (mr *MockELBV2MockRecorder) DeregisterTargetsRequest(arg0 interface{}) *gomock.Call { +// ModifyListenerWithContext indicates an expected call of ModifyListenerWithContext. +func (mr *MockELBV2MockRecorder) ModifyListenerWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsRequest", reflect.TypeOf((*MockELBV2)(nil).DeregisterTargetsRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyListenerWithContext), arg0, arg1) } -// DeregisterTargetsWithContext mocks base method. -func (m *MockELBV2) DeregisterTargetsWithContext(arg0 context.Context, arg1 *elbv2.DeregisterTargetsInput, arg2 ...request.Option) (*elbv2.DeregisterTargetsOutput, error) { +// ModifyLoadBalancerAttributesWithContext mocks base method. +func (m *MockELBV2) ModifyLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyLoadBalancerAttributesInput) (*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeregisterTargetsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput) + ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyLoadBalancerAttributesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DeregisterTargetsWithContext indicates an expected call of DeregisterTargetsWithContext. -func (mr *MockELBV2MockRecorder) DeregisterTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext. +func (mr *MockELBV2MockRecorder) ModifyLoadBalancerAttributesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsWithContext", reflect.TypeOf((*MockELBV2)(nil).DeregisterTargetsWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyLoadBalancerAttributesWithContext), arg0, arg1) } -// DescribeAccountLimits mocks base method. -func (m *MockELBV2) DescribeAccountLimits(arg0 *elbv2.DescribeAccountLimitsInput) (*elbv2.DescribeAccountLimitsOutput, error) { +// ModifyRuleWithContext mocks base method. +func (m *MockELBV2) ModifyRuleWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyRuleInput) (*elasticloadbalancingv2.ModifyRuleOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) - ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput) + ret := m.ctrl.Call(m, "ModifyRuleWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyRuleOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAccountLimits indicates an expected call of DescribeAccountLimits. -func (mr *MockELBV2MockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { +// ModifyRuleWithContext indicates an expected call of ModifyRuleWithContext. +func (mr *MockELBV2MockRecorder) ModifyRuleWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBV2)(nil).DescribeAccountLimits), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyRuleWithContext), arg0, arg1) } -// DescribeAccountLimitsRequest mocks base method. -func (m *MockELBV2) DescribeAccountLimitsRequest(arg0 *elbv2.DescribeAccountLimitsInput) (*request.Request, *elbv2.DescribeAccountLimitsOutput) { +// ModifyTargetGroupAttributesWithContext mocks base method. +func (m *MockELBV2) ModifyTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyTargetGroupAttributesInput) (*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeAccountLimitsOutput) + ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyTargetGroupAttributesOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest. -func (mr *MockELBV2MockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { +// ModifyTargetGroupAttributesWithContext indicates an expected call of ModifyTargetGroupAttributesWithContext. +func (mr *MockELBV2MockRecorder) ModifyTargetGroupAttributesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeAccountLimitsRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupAttributesWithContext), arg0, arg1) } -// DescribeAccountLimitsWithContext mocks base method. -func (m *MockELBV2) DescribeAccountLimitsWithContext(arg0 context.Context, arg1 *elbv2.DescribeAccountLimitsInput, arg2 ...request.Option) (*elbv2.DescribeAccountLimitsOutput, error) { +// ModifyTargetGroupWithContext mocks base method. +func (m *MockELBV2) ModifyTargetGroupWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.ModifyTargetGroupInput) (*elasticloadbalancingv2.ModifyTargetGroupOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAccountLimitsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput) + ret := m.ctrl.Call(m, "ModifyTargetGroupWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.ModifyTargetGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext. -func (mr *MockELBV2MockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// ModifyTargetGroupWithContext indicates an expected call of ModifyTargetGroupWithContext. +func (mr *MockELBV2MockRecorder) ModifyTargetGroupWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeAccountLimitsWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupWithContext), arg0, arg1) } -// DescribeListenerCertificates mocks base method. -func (m *MockELBV2) DescribeListenerCertificates(arg0 *elbv2.DescribeListenerCertificatesInput) (*elbv2.DescribeListenerCertificatesOutput, error) { +// RegisterTargetsWithContext mocks base method. +func (m *MockELBV2) RegisterTargetsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.RegisterTargetsInput) (*elasticloadbalancingv2.RegisterTargetsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenerCertificates", arg0) - ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput) + ret := m.ctrl.Call(m, "RegisterTargetsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.RegisterTargetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListenerCertificates indicates an expected call of DescribeListenerCertificates. -func (mr *MockELBV2MockRecorder) DescribeListenerCertificates(arg0 interface{}) *gomock.Call { +// RegisterTargetsWithContext indicates an expected call of RegisterTargetsWithContext. +func (mr *MockELBV2MockRecorder) RegisterTargetsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificates", reflect.TypeOf((*MockELBV2)(nil).DescribeListenerCertificates), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsWithContext", reflect.TypeOf((*MockELBV2)(nil).RegisterTargetsWithContext), arg0, arg1) } -// DescribeListenerCertificatesAsList mocks base method. -func (m *MockELBV2) DescribeListenerCertificatesAsList(arg0 context.Context, arg1 *elbv2.DescribeListenerCertificatesInput) ([]*elbv2.Certificate, error) { +// RemoveListenerCertificatesWithContext mocks base method. +func (m *MockELBV2) RemoveListenerCertificatesWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.RemoveListenerCertificatesInput) (*elasticloadbalancingv2.RemoveListenerCertificatesOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenerCertificatesAsList", arg0, arg1) - ret0, _ := ret[0].([]*elbv2.Certificate) + ret := m.ctrl.Call(m, "RemoveListenerCertificatesWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.RemoveListenerCertificatesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListenerCertificatesAsList indicates an expected call of DescribeListenerCertificatesAsList. -func (mr *MockELBV2MockRecorder) DescribeListenerCertificatesAsList(arg0, arg1 interface{}) *gomock.Call { +// RemoveListenerCertificatesWithContext indicates an expected call of RemoveListenerCertificatesWithContext. +func (mr *MockELBV2MockRecorder) RemoveListenerCertificatesWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeListenerCertificatesAsList), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2)(nil).RemoveListenerCertificatesWithContext), arg0, arg1) } -// DescribeListenerCertificatesRequest mocks base method. -func (m *MockELBV2) DescribeListenerCertificatesRequest(arg0 *elbv2.DescribeListenerCertificatesInput) (*request.Request, *elbv2.DescribeListenerCertificatesOutput) { +// RemoveTagsWithContext mocks base method. +func (m *MockELBV2) RemoveTagsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.RemoveTagsInput) (*elasticloadbalancingv2.RemoveTagsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenerCertificatesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeListenerCertificatesOutput) + ret := m.ctrl.Call(m, "RemoveTagsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.RemoveTagsOutput) + ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListenerCertificatesRequest indicates an expected call of DescribeListenerCertificatesRequest. -func (mr *MockELBV2MockRecorder) DescribeListenerCertificatesRequest(arg0 interface{}) *gomock.Call { +// RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext. +func (mr *MockELBV2MockRecorder) RemoveTagsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeListenerCertificatesRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).RemoveTagsWithContext), arg0, arg1) } -// DescribeListenerCertificatesWithContext mocks base method. -func (m *MockELBV2) DescribeListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenerCertificatesInput, arg2 ...request.Option) (*elbv2.DescribeListenerCertificatesOutput, error) { +// SetIpAddressTypeWithContext mocks base method. +func (m *MockELBV2) SetIpAddressTypeWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.SetIpAddressTypeInput) (*elasticloadbalancingv2.SetIpAddressTypeOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeListenerCertificatesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput) + ret := m.ctrl.Call(m, "SetIpAddressTypeWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.SetIpAddressTypeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListenerCertificatesWithContext indicates an expected call of DescribeListenerCertificatesWithContext. -func (mr *MockELBV2MockRecorder) DescribeListenerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// SetIpAddressTypeWithContext indicates an expected call of SetIpAddressTypeWithContext. +func (mr *MockELBV2MockRecorder) SetIpAddressTypeWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeListenerCertificatesWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeWithContext", reflect.TypeOf((*MockELBV2)(nil).SetIpAddressTypeWithContext), arg0, arg1) } -// DescribeListeners mocks base method. -func (m *MockELBV2) DescribeListeners(arg0 *elbv2.DescribeListenersInput) (*elbv2.DescribeListenersOutput, error) { +// SetSecurityGroupsWithContext mocks base method. +func (m *MockELBV2) SetSecurityGroupsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.SetSecurityGroupsInput) (*elasticloadbalancingv2.SetSecurityGroupsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListeners", arg0) - ret0, _ := ret[0].(*elbv2.DescribeListenersOutput) + ret := m.ctrl.Call(m, "SetSecurityGroupsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.SetSecurityGroupsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListeners indicates an expected call of DescribeListeners. -func (mr *MockELBV2MockRecorder) DescribeListeners(arg0 interface{}) *gomock.Call { +// SetSecurityGroupsWithContext indicates an expected call of SetSecurityGroupsWithContext. +func (mr *MockELBV2MockRecorder) SetSecurityGroupsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockELBV2)(nil).DescribeListeners), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsWithContext", reflect.TypeOf((*MockELBV2)(nil).SetSecurityGroupsWithContext), arg0, arg1) } -// DescribeListenersAsList mocks base method. -func (m *MockELBV2) DescribeListenersAsList(arg0 context.Context, arg1 *elbv2.DescribeListenersInput) ([]*elbv2.Listener, error) { +// SetSubnetsWithContext mocks base method. +func (m *MockELBV2) SetSubnetsWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.SetSubnetsInput) (*elasticloadbalancingv2.SetSubnetsOutput, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenersAsList", arg0, arg1) - ret0, _ := ret[0].([]*elbv2.Listener) + ret := m.ctrl.Call(m, "SetSubnetsWithContext", arg0, arg1) + ret0, _ := ret[0].(*elasticloadbalancingv2.SetSubnetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeListenersAsList indicates an expected call of DescribeListenersAsList. -func (mr *MockELBV2MockRecorder) DescribeListenersAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersAsList), arg0, arg1) -} - -// DescribeListenersPages mocks base method. -func (m *MockELBV2) DescribeListenersPages(arg0 *elbv2.DescribeListenersInput, arg1 func(*elbv2.DescribeListenersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeListenersPages indicates an expected call of DescribeListenersPages. -func (mr *MockELBV2MockRecorder) DescribeListenersPages(arg0, arg1 interface{}) *gomock.Call { +// SetSubnetsWithContext indicates an expected call of SetSubnetsWithContext. +func (mr *MockELBV2MockRecorder) SetSubnetsWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersPages", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersPages), arg0, arg1) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsWithContext", reflect.TypeOf((*MockELBV2)(nil).SetSubnetsWithContext), arg0, arg1) } -// DescribeListenersPagesWithContext mocks base method. -func (m *MockELBV2) DescribeListenersPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenersInput, arg2 func(*elbv2.DescribeListenersOutput, bool) bool, arg3 ...request.Option) error { +// WaitUntilLoadBalancerAvailableWithContext mocks base method. +func (m *MockELBV2) WaitUntilLoadBalancerAvailableWithContext(arg0 context.Context, arg1 *elasticloadbalancingv2.DescribeLoadBalancersInput) error { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1, arg2} - for _, a := range arg3 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeListenersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeListenersPagesWithContext indicates an expected call of DescribeListenersPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeListenersPagesWithContext(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, "DescribeListenersPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersPagesWithContext), varargs...) -} - -// DescribeListenersRequest mocks base method. -func (m *MockELBV2) DescribeListenersRequest(arg0 *elbv2.DescribeListenersInput) (*request.Request, *elbv2.DescribeListenersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeListenersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeListenersOutput) - return ret0, ret1 -} - -// DescribeListenersRequest indicates an expected call of DescribeListenersRequest. -func (mr *MockELBV2MockRecorder) DescribeListenersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersRequest), arg0) -} - -// DescribeListenersWithContext mocks base method. -func (m *MockELBV2) DescribeListenersWithContext(arg0 context.Context, arg1 *elbv2.DescribeListenersInput, arg2 ...request.Option) (*elbv2.DescribeListenersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeListenersWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeListenersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeListenersWithContext indicates an expected call of DescribeListenersWithContext. -func (mr *MockELBV2MockRecorder) DescribeListenersWithContext(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, "DescribeListenersWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeListenersWithContext), varargs...) -} - -// DescribeLoadBalancerAttributes mocks base method. -func (m *MockELBV2) DescribeLoadBalancerAttributes(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*elbv2.DescribeLoadBalancerAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributes", arg0) - ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLoadBalancerAttributes indicates an expected call of DescribeLoadBalancerAttributes. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancerAttributes), arg0) -} - -// DescribeLoadBalancerAttributesRequest mocks base method. -func (m *MockELBV2) DescribeLoadBalancerAttributesRequest(arg0 *elbv2.DescribeLoadBalancerAttributesInput) (*request.Request, *elbv2.DescribeLoadBalancerAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeLoadBalancerAttributesOutput) - return ret0, ret1 -} - -// DescribeLoadBalancerAttributesRequest indicates an expected call of DescribeLoadBalancerAttributesRequest. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancerAttributesRequest), arg0) -} - -// DescribeLoadBalancerAttributesWithContext mocks base method. -func (m *MockELBV2) DescribeLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.DescribeLoadBalancerAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLoadBalancerAttributesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeLoadBalancerAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLoadBalancerAttributesWithContext indicates an expected call of DescribeLoadBalancerAttributesWithContext. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancerAttributesWithContext(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, "DescribeLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancerAttributesWithContext), varargs...) -} - -// DescribeLoadBalancers mocks base method. -func (m *MockELBV2) DescribeLoadBalancers(arg0 *elbv2.DescribeLoadBalancersInput) (*elbv2.DescribeLoadBalancersOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0) - ret0, _ := ret[0].(*elbv2.DescribeLoadBalancersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancers), arg0) -} - -// DescribeLoadBalancersAsList mocks base method. -func (m *MockELBV2) DescribeLoadBalancersAsList(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput) ([]*elbv2.LoadBalancer, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancersAsList", arg0, arg1) - ret0, _ := ret[0].([]*elbv2.LoadBalancer) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLoadBalancersAsList indicates an expected call of DescribeLoadBalancersAsList. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancersAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersAsList), arg0, arg1) -} - -// DescribeLoadBalancersPages mocks base method. -func (m *MockELBV2) DescribeLoadBalancersPages(arg0 *elbv2.DescribeLoadBalancersInput, arg1 func(*elbv2.DescribeLoadBalancersOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancersPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLoadBalancersPages indicates an expected call of DescribeLoadBalancersPages. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersPages), arg0, arg1) -} - -// DescribeLoadBalancersPagesWithContext mocks base method. -func (m *MockELBV2) DescribeLoadBalancersPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 func(*elbv2.DescribeLoadBalancersOutput, 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, "DescribeLoadBalancersPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeLoadBalancersPagesWithContext indicates an expected call of DescribeLoadBalancersPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancersPagesWithContext(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, "DescribeLoadBalancersPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersPagesWithContext), varargs...) -} - -// DescribeLoadBalancersRequest mocks base method. -func (m *MockELBV2) DescribeLoadBalancersRequest(arg0 *elbv2.DescribeLoadBalancersInput) (*request.Request, *elbv2.DescribeLoadBalancersOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeLoadBalancersOutput) - return ret0, ret1 -} - -// DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersRequest), arg0) -} - -// DescribeLoadBalancersWithContext mocks base method. -func (m *MockELBV2) DescribeLoadBalancersWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, arg2 ...request.Option) (*elbv2.DescribeLoadBalancersOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeLoadBalancersWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeLoadBalancersOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext. -func (mr *MockELBV2MockRecorder) DescribeLoadBalancersWithContext(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, "DescribeLoadBalancersWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeLoadBalancersWithContext), varargs...) -} - -// DescribeRules mocks base method. -func (m *MockELBV2) DescribeRules(arg0 *elbv2.DescribeRulesInput) (*elbv2.DescribeRulesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRules", arg0) - ret0, _ := ret[0].(*elbv2.DescribeRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRules indicates an expected call of DescribeRules. -func (mr *MockELBV2MockRecorder) DescribeRules(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRules", reflect.TypeOf((*MockELBV2)(nil).DescribeRules), arg0) -} - -// DescribeRulesAsList mocks base method. -func (m *MockELBV2) DescribeRulesAsList(arg0 context.Context, arg1 *elbv2.DescribeRulesInput) ([]*elbv2.Rule, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRulesAsList", arg0, arg1) - ret0, _ := ret[0].([]*elbv2.Rule) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRulesAsList indicates an expected call of DescribeRulesAsList. -func (mr *MockELBV2MockRecorder) DescribeRulesAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeRulesAsList), arg0, arg1) -} - -// DescribeRulesRequest mocks base method. -func (m *MockELBV2) DescribeRulesRequest(arg0 *elbv2.DescribeRulesInput) (*request.Request, *elbv2.DescribeRulesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeRulesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeRulesOutput) - return ret0, ret1 -} - -// DescribeRulesRequest indicates an expected call of DescribeRulesRequest. -func (mr *MockELBV2MockRecorder) DescribeRulesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeRulesRequest), arg0) -} - -// DescribeRulesWithContext mocks base method. -func (m *MockELBV2) DescribeRulesWithContext(arg0 context.Context, arg1 *elbv2.DescribeRulesInput, arg2 ...request.Option) (*elbv2.DescribeRulesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeRulesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeRulesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeRulesWithContext indicates an expected call of DescribeRulesWithContext. -func (mr *MockELBV2MockRecorder) DescribeRulesWithContext(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, "DescribeRulesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeRulesWithContext), varargs...) -} - -// DescribeSSLPolicies mocks base method. -func (m *MockELBV2) DescribeSSLPolicies(arg0 *elbv2.DescribeSSLPoliciesInput) (*elbv2.DescribeSSLPoliciesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSSLPolicies", arg0) - ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSSLPolicies indicates an expected call of DescribeSSLPolicies. -func (mr *MockELBV2MockRecorder) DescribeSSLPolicies(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPolicies", reflect.TypeOf((*MockELBV2)(nil).DescribeSSLPolicies), arg0) -} - -// DescribeSSLPoliciesRequest mocks base method. -func (m *MockELBV2) DescribeSSLPoliciesRequest(arg0 *elbv2.DescribeSSLPoliciesInput) (*request.Request, *elbv2.DescribeSSLPoliciesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSSLPoliciesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeSSLPoliciesOutput) - return ret0, ret1 -} - -// DescribeSSLPoliciesRequest indicates an expected call of DescribeSSLPoliciesRequest. -func (mr *MockELBV2MockRecorder) DescribeSSLPoliciesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPoliciesRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeSSLPoliciesRequest), arg0) -} - -// DescribeSSLPoliciesWithContext mocks base method. -func (m *MockELBV2) DescribeSSLPoliciesWithContext(arg0 context.Context, arg1 *elbv2.DescribeSSLPoliciesInput, arg2 ...request.Option) (*elbv2.DescribeSSLPoliciesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSSLPoliciesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeSSLPoliciesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSSLPoliciesWithContext indicates an expected call of DescribeSSLPoliciesWithContext. -func (mr *MockELBV2MockRecorder) DescribeSSLPoliciesWithContext(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, "DescribeSSLPoliciesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeSSLPoliciesWithContext), varargs...) -} - -// DescribeTags mocks base method. -func (m *MockELBV2) DescribeTags(arg0 *elbv2.DescribeTagsInput) (*elbv2.DescribeTagsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTags", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTags indicates an expected call of DescribeTags. -func (mr *MockELBV2MockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBV2)(nil).DescribeTags), arg0) -} - -// DescribeTagsRequest mocks base method. -func (m *MockELBV2) DescribeTagsRequest(arg0 *elbv2.DescribeTagsInput) (*request.Request, *elbv2.DescribeTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTagsOutput) - return ret0, ret1 -} - -// DescribeTagsRequest indicates an expected call of DescribeTagsRequest. -func (mr *MockELBV2MockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTagsRequest), arg0) -} - -// DescribeTagsWithContext mocks base method. -func (m *MockELBV2) DescribeTagsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTagsInput, arg2 ...request.Option) (*elbv2.DescribeTagsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext. -func (mr *MockELBV2MockRecorder) DescribeTagsWithContext(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, "DescribeTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTagsWithContext), varargs...) -} - -// DescribeTargetGroupAttributes mocks base method. -func (m *MockELBV2) DescribeTargetGroupAttributes(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*elbv2.DescribeTargetGroupAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroupAttributes", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetGroupAttributes indicates an expected call of DescribeTargetGroupAttributes. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributes", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupAttributes), arg0) -} - -// DescribeTargetGroupAttributesRequest mocks base method. -func (m *MockELBV2) DescribeTargetGroupAttributesRequest(arg0 *elbv2.DescribeTargetGroupAttributesInput) (*request.Request, *elbv2.DescribeTargetGroupAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTargetGroupAttributesOutput) - return ret0, ret1 -} - -// DescribeTargetGroupAttributesRequest indicates an expected call of DescribeTargetGroupAttributesRequest. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupAttributesRequest), arg0) -} - -// DescribeTargetGroupAttributesWithContext mocks base method. -func (m *MockELBV2) DescribeTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTargetGroupAttributesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTargetGroupAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetGroupAttributesWithContext indicates an expected call of DescribeTargetGroupAttributesWithContext. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupAttributesWithContext(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, "DescribeTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupAttributesWithContext), varargs...) -} - -// DescribeTargetGroups mocks base method. -func (m *MockELBV2) DescribeTargetGroups(arg0 *elbv2.DescribeTargetGroupsInput) (*elbv2.DescribeTargetGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroups", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetGroups indicates an expected call of DescribeTargetGroups. -func (mr *MockELBV2MockRecorder) DescribeTargetGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroups", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroups), arg0) -} - -// DescribeTargetGroupsAsList mocks base method. -func (m *MockELBV2) DescribeTargetGroupsAsList(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupsInput) ([]*elbv2.TargetGroup, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroupsAsList", arg0, arg1) - ret0, _ := ret[0].([]*elbv2.TargetGroup) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetGroupsAsList indicates an expected call of DescribeTargetGroupsAsList. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupsAsList(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsAsList", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsAsList), arg0, arg1) -} - -// DescribeTargetGroupsPages mocks base method. -func (m *MockELBV2) DescribeTargetGroupsPages(arg0 *elbv2.DescribeTargetGroupsInput, arg1 func(*elbv2.DescribeTargetGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTargetGroupsPages indicates an expected call of DescribeTargetGroupsPages. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsPages", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsPages), arg0, arg1) -} - -// DescribeTargetGroupsPagesWithContext mocks base method. -func (m *MockELBV2) DescribeTargetGroupsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 func(*elbv2.DescribeTargetGroupsOutput, 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, "DescribeTargetGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTargetGroupsPagesWithContext indicates an expected call of DescribeTargetGroupsPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupsPagesWithContext(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, "DescribeTargetGroupsPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsPagesWithContext), varargs...) -} - -// DescribeTargetGroupsRequest mocks base method. -func (m *MockELBV2) DescribeTargetGroupsRequest(arg0 *elbv2.DescribeTargetGroupsInput) (*request.Request, *elbv2.DescribeTargetGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTargetGroupsOutput) - return ret0, ret1 -} - -// DescribeTargetGroupsRequest indicates an expected call of DescribeTargetGroupsRequest. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsRequest), arg0) -} - -// DescribeTargetGroupsWithContext mocks base method. -func (m *MockELBV2) DescribeTargetGroupsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetGroupsInput, arg2 ...request.Option) (*elbv2.DescribeTargetGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTargetGroupsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTargetGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetGroupsWithContext indicates an expected call of DescribeTargetGroupsWithContext. -func (mr *MockELBV2MockRecorder) DescribeTargetGroupsWithContext(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, "DescribeTargetGroupsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetGroupsWithContext), varargs...) -} - -// DescribeTargetHealth mocks base method. -func (m *MockELBV2) DescribeTargetHealth(arg0 *elbv2.DescribeTargetHealthInput) (*elbv2.DescribeTargetHealthOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetHealth", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetHealth indicates an expected call of DescribeTargetHealth. -func (mr *MockELBV2MockRecorder) DescribeTargetHealth(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetHealth), arg0) -} - -// DescribeTargetHealthRequest mocks base method. -func (m *MockELBV2) DescribeTargetHealthRequest(arg0 *elbv2.DescribeTargetHealthInput) (*request.Request, *elbv2.DescribeTargetHealthOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTargetHealthRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTargetHealthOutput) - return ret0, ret1 -} - -// DescribeTargetHealthRequest indicates an expected call of DescribeTargetHealthRequest. -func (mr *MockELBV2MockRecorder) DescribeTargetHealthRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetHealthRequest), arg0) -} - -// DescribeTargetHealthWithContext mocks base method. -func (m *MockELBV2) DescribeTargetHealthWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, arg2 ...request.Option) (*elbv2.DescribeTargetHealthOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTargetHealthWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTargetHealthOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTargetHealthWithContext indicates an expected call of DescribeTargetHealthWithContext. -func (mr *MockELBV2MockRecorder) DescribeTargetHealthWithContext(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, "DescribeTargetHealthWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTargetHealthWithContext), varargs...) -} - -// DescribeTrustStoreAssociations mocks base method. -func (m *MockELBV2) DescribeTrustStoreAssociations(arg0 *elbv2.DescribeTrustStoreAssociationsInput) (*elbv2.DescribeTrustStoreAssociationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreAssociations", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoreAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStoreAssociations indicates an expected call of DescribeTrustStoreAssociations. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreAssociations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociations", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreAssociations), arg0) -} - -// DescribeTrustStoreAssociationsPages mocks base method. -func (m *MockELBV2) DescribeTrustStoreAssociationsPages(arg0 *elbv2.DescribeTrustStoreAssociationsInput, arg1 func(*elbv2.DescribeTrustStoreAssociationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoreAssociationsPages indicates an expected call of DescribeTrustStoreAssociationsPages. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreAssociationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociationsPages", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreAssociationsPages), arg0, arg1) -} - -// DescribeTrustStoreAssociationsPagesWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoreAssociationsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreAssociationsInput, arg2 func(*elbv2.DescribeTrustStoreAssociationsOutput, 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, "DescribeTrustStoreAssociationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoreAssociationsPagesWithContext indicates an expected call of DescribeTrustStoreAssociationsPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreAssociationsPagesWithContext(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, "DescribeTrustStoreAssociationsPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreAssociationsPagesWithContext), varargs...) -} - -// DescribeTrustStoreAssociationsRequest mocks base method. -func (m *MockELBV2) DescribeTrustStoreAssociationsRequest(arg0 *elbv2.DescribeTrustStoreAssociationsInput) (*request.Request, *elbv2.DescribeTrustStoreAssociationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTrustStoreAssociationsOutput) - return ret0, ret1 -} - -// DescribeTrustStoreAssociationsRequest indicates an expected call of DescribeTrustStoreAssociationsRequest. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreAssociationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreAssociationsRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreAssociationsRequest), arg0) -} - -// DescribeTrustStoreAssociationsWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoreAssociationsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreAssociationsInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoreAssociationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrustStoreAssociationsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoreAssociationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStoreAssociationsWithContext indicates an expected call of DescribeTrustStoreAssociationsWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreAssociationsWithContext(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, "DescribeTrustStoreAssociationsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreAssociationsWithContext), varargs...) -} - -// DescribeTrustStoreRevocations mocks base method. -func (m *MockELBV2) DescribeTrustStoreRevocations(arg0 *elbv2.DescribeTrustStoreRevocationsInput) (*elbv2.DescribeTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreRevocations", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStoreRevocations indicates an expected call of DescribeTrustStoreRevocations. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreRevocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocations", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreRevocations), arg0) -} - -// DescribeTrustStoreRevocationsPages mocks base method. -func (m *MockELBV2) DescribeTrustStoreRevocationsPages(arg0 *elbv2.DescribeTrustStoreRevocationsInput, arg1 func(*elbv2.DescribeTrustStoreRevocationsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoreRevocationsPages indicates an expected call of DescribeTrustStoreRevocationsPages. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreRevocationsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocationsPages", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreRevocationsPages), arg0, arg1) -} - -// DescribeTrustStoreRevocationsPagesWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoreRevocationsPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreRevocationsInput, arg2 func(*elbv2.DescribeTrustStoreRevocationsOutput, 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, "DescribeTrustStoreRevocationsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoreRevocationsPagesWithContext indicates an expected call of DescribeTrustStoreRevocationsPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreRevocationsPagesWithContext(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, "DescribeTrustStoreRevocationsPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreRevocationsPagesWithContext), varargs...) -} - -// DescribeTrustStoreRevocationsRequest mocks base method. -func (m *MockELBV2) DescribeTrustStoreRevocationsRequest(arg0 *elbv2.DescribeTrustStoreRevocationsInput) (*request.Request, *elbv2.DescribeTrustStoreRevocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTrustStoreRevocationsOutput) - return ret0, ret1 -} - -// DescribeTrustStoreRevocationsRequest indicates an expected call of DescribeTrustStoreRevocationsRequest. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreRevocationsRequest), arg0) -} - -// DescribeTrustStoreRevocationsWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrustStoreRevocationsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStoreRevocationsWithContext indicates an expected call of DescribeTrustStoreRevocationsWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoreRevocationsWithContext(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, "DescribeTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoreRevocationsWithContext), varargs...) -} - -// DescribeTrustStores mocks base method. -func (m *MockELBV2) DescribeTrustStores(arg0 *elbv2.DescribeTrustStoresInput) (*elbv2.DescribeTrustStoresOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStores", arg0) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStores indicates an expected call of DescribeTrustStores. -func (mr *MockELBV2MockRecorder) DescribeTrustStores(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStores", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStores), arg0) -} - -// DescribeTrustStoresPages mocks base method. -func (m *MockELBV2) DescribeTrustStoresPages(arg0 *elbv2.DescribeTrustStoresInput, arg1 func(*elbv2.DescribeTrustStoresOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoresPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoresPages indicates an expected call of DescribeTrustStoresPages. -func (mr *MockELBV2MockRecorder) DescribeTrustStoresPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoresPages", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoresPages), arg0, arg1) -} - -// DescribeTrustStoresPagesWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoresPagesWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoresInput, arg2 func(*elbv2.DescribeTrustStoresOutput, 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, "DescribeTrustStoresPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// DescribeTrustStoresPagesWithContext indicates an expected call of DescribeTrustStoresPagesWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoresPagesWithContext(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, "DescribeTrustStoresPagesWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoresPagesWithContext), varargs...) -} - -// DescribeTrustStoresRequest mocks base method. -func (m *MockELBV2) DescribeTrustStoresRequest(arg0 *elbv2.DescribeTrustStoresInput) (*request.Request, *elbv2.DescribeTrustStoresOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeTrustStoresRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.DescribeTrustStoresOutput) - return ret0, ret1 -} - -// DescribeTrustStoresRequest indicates an expected call of DescribeTrustStoresRequest. -func (mr *MockELBV2MockRecorder) DescribeTrustStoresRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrustStoresRequest", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoresRequest), arg0) -} - -// DescribeTrustStoresWithContext mocks base method. -func (m *MockELBV2) DescribeTrustStoresWithContext(arg0 context.Context, arg1 *elbv2.DescribeTrustStoresInput, arg2 ...request.Option) (*elbv2.DescribeTrustStoresOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeTrustStoresWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.DescribeTrustStoresOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeTrustStoresWithContext indicates an expected call of DescribeTrustStoresWithContext. -func (mr *MockELBV2MockRecorder) DescribeTrustStoresWithContext(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, "DescribeTrustStoresWithContext", reflect.TypeOf((*MockELBV2)(nil).DescribeTrustStoresWithContext), varargs...) -} - -// GetTrustStoreCaCertificatesBundle mocks base method. -func (m *MockELBV2) GetTrustStoreCaCertificatesBundle(arg0 *elbv2.GetTrustStoreCaCertificatesBundleInput) (*elbv2.GetTrustStoreCaCertificatesBundleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundle", arg0) - ret0, _ := ret[0].(*elbv2.GetTrustStoreCaCertificatesBundleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTrustStoreCaCertificatesBundle indicates an expected call of GetTrustStoreCaCertificatesBundle. -func (mr *MockELBV2MockRecorder) GetTrustStoreCaCertificatesBundle(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreCaCertificatesBundle", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreCaCertificatesBundle), arg0) -} - -// GetTrustStoreCaCertificatesBundleRequest mocks base method. -func (m *MockELBV2) GetTrustStoreCaCertificatesBundleRequest(arg0 *elbv2.GetTrustStoreCaCertificatesBundleInput) (*request.Request, *elbv2.GetTrustStoreCaCertificatesBundleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.GetTrustStoreCaCertificatesBundleOutput) - return ret0, ret1 -} - -// GetTrustStoreCaCertificatesBundleRequest indicates an expected call of GetTrustStoreCaCertificatesBundleRequest. -func (mr *MockELBV2MockRecorder) GetTrustStoreCaCertificatesBundleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreCaCertificatesBundleRequest", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreCaCertificatesBundleRequest), arg0) -} - -// GetTrustStoreCaCertificatesBundleWithContext mocks base method. -func (m *MockELBV2) GetTrustStoreCaCertificatesBundleWithContext(arg0 context.Context, arg1 *elbv2.GetTrustStoreCaCertificatesBundleInput, arg2 ...request.Option) (*elbv2.GetTrustStoreCaCertificatesBundleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTrustStoreCaCertificatesBundleWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.GetTrustStoreCaCertificatesBundleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTrustStoreCaCertificatesBundleWithContext indicates an expected call of GetTrustStoreCaCertificatesBundleWithContext. -func (mr *MockELBV2MockRecorder) GetTrustStoreCaCertificatesBundleWithContext(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, "GetTrustStoreCaCertificatesBundleWithContext", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreCaCertificatesBundleWithContext), varargs...) -} - -// GetTrustStoreRevocationContent mocks base method. -func (m *MockELBV2) GetTrustStoreRevocationContent(arg0 *elbv2.GetTrustStoreRevocationContentInput) (*elbv2.GetTrustStoreRevocationContentOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTrustStoreRevocationContent", arg0) - ret0, _ := ret[0].(*elbv2.GetTrustStoreRevocationContentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTrustStoreRevocationContent indicates an expected call of GetTrustStoreRevocationContent. -func (mr *MockELBV2MockRecorder) GetTrustStoreRevocationContent(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreRevocationContent", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreRevocationContent), arg0) -} - -// GetTrustStoreRevocationContentRequest mocks base method. -func (m *MockELBV2) GetTrustStoreRevocationContentRequest(arg0 *elbv2.GetTrustStoreRevocationContentInput) (*request.Request, *elbv2.GetTrustStoreRevocationContentOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTrustStoreRevocationContentRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.GetTrustStoreRevocationContentOutput) - return ret0, ret1 -} - -// GetTrustStoreRevocationContentRequest indicates an expected call of GetTrustStoreRevocationContentRequest. -func (mr *MockELBV2MockRecorder) GetTrustStoreRevocationContentRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrustStoreRevocationContentRequest", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreRevocationContentRequest), arg0) -} - -// GetTrustStoreRevocationContentWithContext mocks base method. -func (m *MockELBV2) GetTrustStoreRevocationContentWithContext(arg0 context.Context, arg1 *elbv2.GetTrustStoreRevocationContentInput, arg2 ...request.Option) (*elbv2.GetTrustStoreRevocationContentOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetTrustStoreRevocationContentWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.GetTrustStoreRevocationContentOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetTrustStoreRevocationContentWithContext indicates an expected call of GetTrustStoreRevocationContentWithContext. -func (mr *MockELBV2MockRecorder) GetTrustStoreRevocationContentWithContext(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, "GetTrustStoreRevocationContentWithContext", reflect.TypeOf((*MockELBV2)(nil).GetTrustStoreRevocationContentWithContext), varargs...) -} - -// ModifyListener mocks base method. -func (m *MockELBV2) ModifyListener(arg0 *elbv2.ModifyListenerInput) (*elbv2.ModifyListenerOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyListener", arg0) - ret0, _ := ret[0].(*elbv2.ModifyListenerOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyListener indicates an expected call of ModifyListener. -func (mr *MockELBV2MockRecorder) ModifyListener(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListener", reflect.TypeOf((*MockELBV2)(nil).ModifyListener), arg0) -} - -// ModifyListenerRequest mocks base method. -func (m *MockELBV2) ModifyListenerRequest(arg0 *elbv2.ModifyListenerInput) (*request.Request, *elbv2.ModifyListenerOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyListenerRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyListenerOutput) - return ret0, ret1 -} - -// ModifyListenerRequest indicates an expected call of ModifyListenerRequest. -func (mr *MockELBV2MockRecorder) ModifyListenerRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyListenerRequest), arg0) -} - -// ModifyListenerWithContext mocks base method. -func (m *MockELBV2) ModifyListenerWithContext(arg0 context.Context, arg1 *elbv2.ModifyListenerInput, arg2 ...request.Option) (*elbv2.ModifyListenerOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyListenerWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyListenerOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyListenerWithContext indicates an expected call of ModifyListenerWithContext. -func (mr *MockELBV2MockRecorder) ModifyListenerWithContext(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, "ModifyListenerWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyListenerWithContext), varargs...) -} - -// ModifyLoadBalancerAttributes mocks base method. -func (m *MockELBV2) ModifyLoadBalancerAttributes(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*elbv2.ModifyLoadBalancerAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributes", arg0) - ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLoadBalancerAttributes indicates an expected call of ModifyLoadBalancerAttributes. -func (mr *MockELBV2MockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBV2)(nil).ModifyLoadBalancerAttributes), arg0) -} - -// ModifyLoadBalancerAttributesRequest mocks base method. -func (m *MockELBV2) ModifyLoadBalancerAttributesRequest(arg0 *elbv2.ModifyLoadBalancerAttributesInput) (*request.Request, *elbv2.ModifyLoadBalancerAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyLoadBalancerAttributesOutput) - return ret0, ret1 -} - -// ModifyLoadBalancerAttributesRequest indicates an expected call of ModifyLoadBalancerAttributesRequest. -func (mr *MockELBV2MockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyLoadBalancerAttributesRequest), arg0) -} - -// ModifyLoadBalancerAttributesWithContext mocks base method. -func (m *MockELBV2) ModifyLoadBalancerAttributesWithContext(arg0 context.Context, arg1 *elbv2.ModifyLoadBalancerAttributesInput, arg2 ...request.Option) (*elbv2.ModifyLoadBalancerAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyLoadBalancerAttributesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyLoadBalancerAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyLoadBalancerAttributesWithContext indicates an expected call of ModifyLoadBalancerAttributesWithContext. -func (mr *MockELBV2MockRecorder) ModifyLoadBalancerAttributesWithContext(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, "ModifyLoadBalancerAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyLoadBalancerAttributesWithContext), varargs...) -} - -// ModifyRule mocks base method. -func (m *MockELBV2) ModifyRule(arg0 *elbv2.ModifyRuleInput) (*elbv2.ModifyRuleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyRule", arg0) - ret0, _ := ret[0].(*elbv2.ModifyRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyRule indicates an expected call of ModifyRule. -func (mr *MockELBV2MockRecorder) ModifyRule(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRule", reflect.TypeOf((*MockELBV2)(nil).ModifyRule), arg0) -} - -// ModifyRuleRequest mocks base method. -func (m *MockELBV2) ModifyRuleRequest(arg0 *elbv2.ModifyRuleInput) (*request.Request, *elbv2.ModifyRuleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyRuleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyRuleOutput) - return ret0, ret1 -} - -// ModifyRuleRequest indicates an expected call of ModifyRuleRequest. -func (mr *MockELBV2MockRecorder) ModifyRuleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyRuleRequest), arg0) -} - -// ModifyRuleWithContext mocks base method. -func (m *MockELBV2) ModifyRuleWithContext(arg0 context.Context, arg1 *elbv2.ModifyRuleInput, arg2 ...request.Option) (*elbv2.ModifyRuleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyRuleWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyRuleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyRuleWithContext indicates an expected call of ModifyRuleWithContext. -func (mr *MockELBV2MockRecorder) ModifyRuleWithContext(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, "ModifyRuleWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyRuleWithContext), varargs...) -} - -// ModifyTargetGroup mocks base method. -func (m *MockELBV2) ModifyTargetGroup(arg0 *elbv2.ModifyTargetGroupInput) (*elbv2.ModifyTargetGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTargetGroup", arg0) - ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTargetGroup indicates an expected call of ModifyTargetGroup. -func (mr *MockELBV2MockRecorder) ModifyTargetGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroup", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroup), arg0) -} - -// ModifyTargetGroupAttributes mocks base method. -func (m *MockELBV2) ModifyTargetGroupAttributes(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*elbv2.ModifyTargetGroupAttributesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTargetGroupAttributes", arg0) - ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTargetGroupAttributes indicates an expected call of ModifyTargetGroupAttributes. -func (mr *MockELBV2MockRecorder) ModifyTargetGroupAttributes(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributes", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupAttributes), arg0) -} - -// ModifyTargetGroupAttributesRequest mocks base method. -func (m *MockELBV2) ModifyTargetGroupAttributesRequest(arg0 *elbv2.ModifyTargetGroupAttributesInput) (*request.Request, *elbv2.ModifyTargetGroupAttributesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyTargetGroupAttributesOutput) - return ret0, ret1 -} - -// ModifyTargetGroupAttributesRequest indicates an expected call of ModifyTargetGroupAttributesRequest. -func (mr *MockELBV2MockRecorder) ModifyTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupAttributesRequest), arg0) -} - -// ModifyTargetGroupAttributesWithContext mocks base method. -func (m *MockELBV2) ModifyTargetGroupAttributesWithContext(arg0 context.Context, arg1 *elbv2.ModifyTargetGroupAttributesInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupAttributesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTargetGroupAttributesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyTargetGroupAttributesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTargetGroupAttributesWithContext indicates an expected call of ModifyTargetGroupAttributesWithContext. -func (mr *MockELBV2MockRecorder) ModifyTargetGroupAttributesWithContext(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, "ModifyTargetGroupAttributesWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupAttributesWithContext), varargs...) -} - -// ModifyTargetGroupRequest mocks base method. -func (m *MockELBV2) ModifyTargetGroupRequest(arg0 *elbv2.ModifyTargetGroupInput) (*request.Request, *elbv2.ModifyTargetGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTargetGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyTargetGroupOutput) - return ret0, ret1 -} - -// ModifyTargetGroupRequest indicates an expected call of ModifyTargetGroupRequest. -func (mr *MockELBV2MockRecorder) ModifyTargetGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupRequest), arg0) -} - -// ModifyTargetGroupWithContext mocks base method. -func (m *MockELBV2) ModifyTargetGroupWithContext(arg0 context.Context, arg1 *elbv2.ModifyTargetGroupInput, arg2 ...request.Option) (*elbv2.ModifyTargetGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTargetGroupWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyTargetGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTargetGroupWithContext indicates an expected call of ModifyTargetGroupWithContext. -func (mr *MockELBV2MockRecorder) ModifyTargetGroupWithContext(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, "ModifyTargetGroupWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyTargetGroupWithContext), varargs...) -} - -// ModifyTrustStore mocks base method. -func (m *MockELBV2) ModifyTrustStore(arg0 *elbv2.ModifyTrustStoreInput) (*elbv2.ModifyTrustStoreOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrustStore", arg0) - ret0, _ := ret[0].(*elbv2.ModifyTrustStoreOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrustStore indicates an expected call of ModifyTrustStore. -func (mr *MockELBV2MockRecorder) ModifyTrustStore(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrustStore", reflect.TypeOf((*MockELBV2)(nil).ModifyTrustStore), arg0) -} - -// ModifyTrustStoreRequest mocks base method. -func (m *MockELBV2) ModifyTrustStoreRequest(arg0 *elbv2.ModifyTrustStoreInput) (*request.Request, *elbv2.ModifyTrustStoreOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ModifyTrustStoreRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.ModifyTrustStoreOutput) - return ret0, ret1 -} - -// ModifyTrustStoreRequest indicates an expected call of ModifyTrustStoreRequest. -func (mr *MockELBV2MockRecorder) ModifyTrustStoreRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrustStoreRequest", reflect.TypeOf((*MockELBV2)(nil).ModifyTrustStoreRequest), arg0) -} - -// ModifyTrustStoreWithContext mocks base method. -func (m *MockELBV2) ModifyTrustStoreWithContext(arg0 context.Context, arg1 *elbv2.ModifyTrustStoreInput, arg2 ...request.Option) (*elbv2.ModifyTrustStoreOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ModifyTrustStoreWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.ModifyTrustStoreOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ModifyTrustStoreWithContext indicates an expected call of ModifyTrustStoreWithContext. -func (mr *MockELBV2MockRecorder) ModifyTrustStoreWithContext(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, "ModifyTrustStoreWithContext", reflect.TypeOf((*MockELBV2)(nil).ModifyTrustStoreWithContext), varargs...) -} - -// RegisterTargets mocks base method. -func (m *MockELBV2) RegisterTargets(arg0 *elbv2.RegisterTargetsInput) (*elbv2.RegisterTargetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTargets", arg0) - ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTargets indicates an expected call of RegisterTargets. -func (mr *MockELBV2MockRecorder) RegisterTargets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargets", reflect.TypeOf((*MockELBV2)(nil).RegisterTargets), arg0) -} - -// RegisterTargetsRequest mocks base method. -func (m *MockELBV2) RegisterTargetsRequest(arg0 *elbv2.RegisterTargetsInput) (*request.Request, *elbv2.RegisterTargetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RegisterTargetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.RegisterTargetsOutput) - return ret0, ret1 -} - -// RegisterTargetsRequest indicates an expected call of RegisterTargetsRequest. -func (mr *MockELBV2MockRecorder) RegisterTargetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsRequest", reflect.TypeOf((*MockELBV2)(nil).RegisterTargetsRequest), arg0) -} - -// RegisterTargetsWithContext mocks base method. -func (m *MockELBV2) RegisterTargetsWithContext(arg0 context.Context, arg1 *elbv2.RegisterTargetsInput, arg2 ...request.Option) (*elbv2.RegisterTargetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RegisterTargetsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.RegisterTargetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RegisterTargetsWithContext indicates an expected call of RegisterTargetsWithContext. -func (mr *MockELBV2MockRecorder) RegisterTargetsWithContext(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, "RegisterTargetsWithContext", reflect.TypeOf((*MockELBV2)(nil).RegisterTargetsWithContext), varargs...) -} - -// RemoveListenerCertificates mocks base method. -func (m *MockELBV2) RemoveListenerCertificates(arg0 *elbv2.RemoveListenerCertificatesInput) (*elbv2.RemoveListenerCertificatesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveListenerCertificates", arg0) - ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveListenerCertificates indicates an expected call of RemoveListenerCertificates. -func (mr *MockELBV2MockRecorder) RemoveListenerCertificates(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificates", reflect.TypeOf((*MockELBV2)(nil).RemoveListenerCertificates), arg0) -} - -// RemoveListenerCertificatesRequest mocks base method. -func (m *MockELBV2) RemoveListenerCertificatesRequest(arg0 *elbv2.RemoveListenerCertificatesInput) (*request.Request, *elbv2.RemoveListenerCertificatesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveListenerCertificatesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.RemoveListenerCertificatesOutput) - return ret0, ret1 -} - -// RemoveListenerCertificatesRequest indicates an expected call of RemoveListenerCertificatesRequest. -func (mr *MockELBV2MockRecorder) RemoveListenerCertificatesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesRequest", reflect.TypeOf((*MockELBV2)(nil).RemoveListenerCertificatesRequest), arg0) -} - -// RemoveListenerCertificatesWithContext mocks base method. -func (m *MockELBV2) RemoveListenerCertificatesWithContext(arg0 context.Context, arg1 *elbv2.RemoveListenerCertificatesInput, arg2 ...request.Option) (*elbv2.RemoveListenerCertificatesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RemoveListenerCertificatesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.RemoveListenerCertificatesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveListenerCertificatesWithContext indicates an expected call of RemoveListenerCertificatesWithContext. -func (mr *MockELBV2MockRecorder) RemoveListenerCertificatesWithContext(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, "RemoveListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2)(nil).RemoveListenerCertificatesWithContext), varargs...) -} - -// RemoveTags mocks base method. -func (m *MockELBV2) RemoveTags(arg0 *elbv2.RemoveTagsInput) (*elbv2.RemoveTagsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTags", arg0) - ret0, _ := ret[0].(*elbv2.RemoveTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTags indicates an expected call of RemoveTags. -func (mr *MockELBV2MockRecorder) RemoveTags(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBV2)(nil).RemoveTags), arg0) -} - -// RemoveTagsRequest mocks base method. -func (m *MockELBV2) RemoveTagsRequest(arg0 *elbv2.RemoveTagsInput) (*request.Request, *elbv2.RemoveTagsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTagsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.RemoveTagsOutput) - return ret0, ret1 -} - -// RemoveTagsRequest indicates an expected call of RemoveTagsRequest. -func (mr *MockELBV2MockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBV2)(nil).RemoveTagsRequest), arg0) -} - -// RemoveTagsWithContext mocks base method. -func (m *MockELBV2) RemoveTagsWithContext(arg0 context.Context, arg1 *elbv2.RemoveTagsInput, arg2 ...request.Option) (*elbv2.RemoveTagsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RemoveTagsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.RemoveTagsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTagsWithContext indicates an expected call of RemoveTagsWithContext. -func (mr *MockELBV2MockRecorder) RemoveTagsWithContext(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, "RemoveTagsWithContext", reflect.TypeOf((*MockELBV2)(nil).RemoveTagsWithContext), varargs...) -} - -// RemoveTrustStoreRevocations mocks base method. -func (m *MockELBV2) RemoveTrustStoreRevocations(arg0 *elbv2.RemoveTrustStoreRevocationsInput) (*elbv2.RemoveTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTrustStoreRevocations", arg0) - ret0, _ := ret[0].(*elbv2.RemoveTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTrustStoreRevocations indicates an expected call of RemoveTrustStoreRevocations. -func (mr *MockELBV2MockRecorder) RemoveTrustStoreRevocations(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTrustStoreRevocations", reflect.TypeOf((*MockELBV2)(nil).RemoveTrustStoreRevocations), arg0) -} - -// RemoveTrustStoreRevocationsRequest mocks base method. -func (m *MockELBV2) RemoveTrustStoreRevocationsRequest(arg0 *elbv2.RemoveTrustStoreRevocationsInput) (*request.Request, *elbv2.RemoveTrustStoreRevocationsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "RemoveTrustStoreRevocationsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.RemoveTrustStoreRevocationsOutput) - return ret0, ret1 -} - -// RemoveTrustStoreRevocationsRequest indicates an expected call of RemoveTrustStoreRevocationsRequest. -func (mr *MockELBV2MockRecorder) RemoveTrustStoreRevocationsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTrustStoreRevocationsRequest", reflect.TypeOf((*MockELBV2)(nil).RemoveTrustStoreRevocationsRequest), arg0) -} - -// RemoveTrustStoreRevocationsWithContext mocks base method. -func (m *MockELBV2) RemoveTrustStoreRevocationsWithContext(arg0 context.Context, arg1 *elbv2.RemoveTrustStoreRevocationsInput, arg2 ...request.Option) (*elbv2.RemoveTrustStoreRevocationsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "RemoveTrustStoreRevocationsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.RemoveTrustStoreRevocationsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// RemoveTrustStoreRevocationsWithContext indicates an expected call of RemoveTrustStoreRevocationsWithContext. -func (mr *MockELBV2MockRecorder) RemoveTrustStoreRevocationsWithContext(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, "RemoveTrustStoreRevocationsWithContext", reflect.TypeOf((*MockELBV2)(nil).RemoveTrustStoreRevocationsWithContext), varargs...) -} - -// SetIpAddressType mocks base method. -func (m *MockELBV2) SetIpAddressType(arg0 *elbv2.SetIpAddressTypeInput) (*elbv2.SetIpAddressTypeOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetIpAddressType", arg0) - ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetIpAddressType indicates an expected call of SetIpAddressType. -func (mr *MockELBV2MockRecorder) SetIpAddressType(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressType", reflect.TypeOf((*MockELBV2)(nil).SetIpAddressType), arg0) -} - -// SetIpAddressTypeRequest mocks base method. -func (m *MockELBV2) SetIpAddressTypeRequest(arg0 *elbv2.SetIpAddressTypeInput) (*request.Request, *elbv2.SetIpAddressTypeOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetIpAddressTypeRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.SetIpAddressTypeOutput) - return ret0, ret1 -} - -// SetIpAddressTypeRequest indicates an expected call of SetIpAddressTypeRequest. -func (mr *MockELBV2MockRecorder) SetIpAddressTypeRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeRequest", reflect.TypeOf((*MockELBV2)(nil).SetIpAddressTypeRequest), arg0) -} - -// SetIpAddressTypeWithContext mocks base method. -func (m *MockELBV2) SetIpAddressTypeWithContext(arg0 context.Context, arg1 *elbv2.SetIpAddressTypeInput, arg2 ...request.Option) (*elbv2.SetIpAddressTypeOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SetIpAddressTypeWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.SetIpAddressTypeOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetIpAddressTypeWithContext indicates an expected call of SetIpAddressTypeWithContext. -func (mr *MockELBV2MockRecorder) SetIpAddressTypeWithContext(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, "SetIpAddressTypeWithContext", reflect.TypeOf((*MockELBV2)(nil).SetIpAddressTypeWithContext), varargs...) -} - -// SetRulePriorities mocks base method. -func (m *MockELBV2) SetRulePriorities(arg0 *elbv2.SetRulePrioritiesInput) (*elbv2.SetRulePrioritiesOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRulePriorities", arg0) - ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetRulePriorities indicates an expected call of SetRulePriorities. -func (mr *MockELBV2MockRecorder) SetRulePriorities(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePriorities", reflect.TypeOf((*MockELBV2)(nil).SetRulePriorities), arg0) -} - -// SetRulePrioritiesRequest mocks base method. -func (m *MockELBV2) SetRulePrioritiesRequest(arg0 *elbv2.SetRulePrioritiesInput) (*request.Request, *elbv2.SetRulePrioritiesOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetRulePrioritiesRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.SetRulePrioritiesOutput) - return ret0, ret1 -} - -// SetRulePrioritiesRequest indicates an expected call of SetRulePrioritiesRequest. -func (mr *MockELBV2MockRecorder) SetRulePrioritiesRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePrioritiesRequest", reflect.TypeOf((*MockELBV2)(nil).SetRulePrioritiesRequest), arg0) -} - -// SetRulePrioritiesWithContext mocks base method. -func (m *MockELBV2) SetRulePrioritiesWithContext(arg0 context.Context, arg1 *elbv2.SetRulePrioritiesInput, arg2 ...request.Option) (*elbv2.SetRulePrioritiesOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SetRulePrioritiesWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.SetRulePrioritiesOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetRulePrioritiesWithContext indicates an expected call of SetRulePrioritiesWithContext. -func (mr *MockELBV2MockRecorder) SetRulePrioritiesWithContext(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, "SetRulePrioritiesWithContext", reflect.TypeOf((*MockELBV2)(nil).SetRulePrioritiesWithContext), varargs...) -} - -// SetSecurityGroups mocks base method. -func (m *MockELBV2) SetSecurityGroups(arg0 *elbv2.SetSecurityGroupsInput) (*elbv2.SetSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetSecurityGroups", arg0) - ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetSecurityGroups indicates an expected call of SetSecurityGroups. -func (mr *MockELBV2MockRecorder) SetSecurityGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroups", reflect.TypeOf((*MockELBV2)(nil).SetSecurityGroups), arg0) -} - -// SetSecurityGroupsRequest mocks base method. -func (m *MockELBV2) SetSecurityGroupsRequest(arg0 *elbv2.SetSecurityGroupsInput) (*request.Request, *elbv2.SetSecurityGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetSecurityGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.SetSecurityGroupsOutput) - return ret0, ret1 -} - -// SetSecurityGroupsRequest indicates an expected call of SetSecurityGroupsRequest. -func (mr *MockELBV2MockRecorder) SetSecurityGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsRequest", reflect.TypeOf((*MockELBV2)(nil).SetSecurityGroupsRequest), arg0) -} - -// SetSecurityGroupsWithContext mocks base method. -func (m *MockELBV2) SetSecurityGroupsWithContext(arg0 context.Context, arg1 *elbv2.SetSecurityGroupsInput, arg2 ...request.Option) (*elbv2.SetSecurityGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SetSecurityGroupsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.SetSecurityGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetSecurityGroupsWithContext indicates an expected call of SetSecurityGroupsWithContext. -func (mr *MockELBV2MockRecorder) SetSecurityGroupsWithContext(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, "SetSecurityGroupsWithContext", reflect.TypeOf((*MockELBV2)(nil).SetSecurityGroupsWithContext), varargs...) -} - -// SetSubnets mocks base method. -func (m *MockELBV2) SetSubnets(arg0 *elbv2.SetSubnetsInput) (*elbv2.SetSubnetsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetSubnets", arg0) - ret0, _ := ret[0].(*elbv2.SetSubnetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetSubnets indicates an expected call of SetSubnets. -func (mr *MockELBV2MockRecorder) SetSubnets(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnets", reflect.TypeOf((*MockELBV2)(nil).SetSubnets), arg0) -} - -// SetSubnetsRequest mocks base method. -func (m *MockELBV2) SetSubnetsRequest(arg0 *elbv2.SetSubnetsInput) (*request.Request, *elbv2.SetSubnetsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "SetSubnetsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*elbv2.SetSubnetsOutput) - return ret0, ret1 -} - -// SetSubnetsRequest indicates an expected call of SetSubnetsRequest. -func (mr *MockELBV2MockRecorder) SetSubnetsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsRequest", reflect.TypeOf((*MockELBV2)(nil).SetSubnetsRequest), arg0) -} - -// SetSubnetsWithContext mocks base method. -func (m *MockELBV2) SetSubnetsWithContext(arg0 context.Context, arg1 *elbv2.SetSubnetsInput, arg2 ...request.Option) (*elbv2.SetSubnetsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "SetSubnetsWithContext", varargs...) - ret0, _ := ret[0].(*elbv2.SetSubnetsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// SetSubnetsWithContext indicates an expected call of SetSubnetsWithContext. -func (mr *MockELBV2MockRecorder) SetSubnetsWithContext(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, "SetSubnetsWithContext", reflect.TypeOf((*MockELBV2)(nil).SetSubnetsWithContext), varargs...) -} - -// WaitUntilLoadBalancerAvailable mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancerAvailable(arg0 *elbv2.DescribeLoadBalancersInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailable", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilLoadBalancerAvailable indicates an expected call of WaitUntilLoadBalancerAvailable. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancerAvailable(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailable", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancerAvailable), arg0) -} - -// WaitUntilLoadBalancerAvailableWithContext mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancerAvailableWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancerAvailableWithContext", varargs...) + ret := m.ctrl.Call(m, "WaitUntilLoadBalancerAvailableWithContext", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // WaitUntilLoadBalancerAvailableWithContext indicates an expected call of WaitUntilLoadBalancerAvailableWithContext. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancerAvailableWithContext(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, "WaitUntilLoadBalancerAvailableWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancerAvailableWithContext), varargs...) -} - -// WaitUntilLoadBalancerExists mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancerExists(arg0 *elbv2.DescribeLoadBalancersInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilLoadBalancerExists", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilLoadBalancerExists indicates an expected call of WaitUntilLoadBalancerExists. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancerExists(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerExists", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancerExists), arg0) -} - -// WaitUntilLoadBalancerExistsWithContext mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancerExistsWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancerExistsWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilLoadBalancerExistsWithContext indicates an expected call of WaitUntilLoadBalancerExistsWithContext. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancerExistsWithContext(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, "WaitUntilLoadBalancerExistsWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancerExistsWithContext), varargs...) -} - -// WaitUntilLoadBalancersDeleted mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancersDeleted(arg0 *elbv2.DescribeLoadBalancersInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilLoadBalancersDeleted", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilLoadBalancersDeleted indicates an expected call of WaitUntilLoadBalancersDeleted. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancersDeleted(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancersDeleted", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancersDeleted), arg0) -} - -// WaitUntilLoadBalancersDeletedWithContext mocks base method. -func (m *MockELBV2) WaitUntilLoadBalancersDeletedWithContext(arg0 context.Context, arg1 *elbv2.DescribeLoadBalancersInput, 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, "WaitUntilLoadBalancersDeletedWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilLoadBalancersDeletedWithContext indicates an expected call of WaitUntilLoadBalancersDeletedWithContext. -func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancersDeletedWithContext(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, "WaitUntilLoadBalancersDeletedWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancersDeletedWithContext), varargs...) -} - -// WaitUntilTargetDeregistered mocks base method. -func (m *MockELBV2) WaitUntilTargetDeregistered(arg0 *elbv2.DescribeTargetHealthInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilTargetDeregistered", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilTargetDeregistered indicates an expected call of WaitUntilTargetDeregistered. -func (mr *MockELBV2MockRecorder) WaitUntilTargetDeregistered(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetDeregistered", reflect.TypeOf((*MockELBV2)(nil).WaitUntilTargetDeregistered), arg0) -} - -// WaitUntilTargetDeregisteredWithContext mocks base method. -func (m *MockELBV2) WaitUntilTargetDeregisteredWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, 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, "WaitUntilTargetDeregisteredWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilTargetDeregisteredWithContext indicates an expected call of WaitUntilTargetDeregisteredWithContext. -func (mr *MockELBV2MockRecorder) WaitUntilTargetDeregisteredWithContext(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, "WaitUntilTargetDeregisteredWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilTargetDeregisteredWithContext), varargs...) -} - -// WaitUntilTargetInService mocks base method. -func (m *MockELBV2) WaitUntilTargetInService(arg0 *elbv2.DescribeTargetHealthInput) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "WaitUntilTargetInService", arg0) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilTargetInService indicates an expected call of WaitUntilTargetInService. -func (mr *MockELBV2MockRecorder) WaitUntilTargetInService(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInService", reflect.TypeOf((*MockELBV2)(nil).WaitUntilTargetInService), arg0) -} - -// WaitUntilTargetInServiceWithContext mocks base method. -func (m *MockELBV2) WaitUntilTargetInServiceWithContext(arg0 context.Context, arg1 *elbv2.DescribeTargetHealthInput, 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, "WaitUntilTargetInServiceWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// WaitUntilTargetInServiceWithContext indicates an expected call of WaitUntilTargetInServiceWithContext. -func (mr *MockELBV2MockRecorder) WaitUntilTargetInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +func (mr *MockELBV2MockRecorder) WaitUntilLoadBalancerAvailableWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInServiceWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilTargetInServiceWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailableWithContext", reflect.TypeOf((*MockELBV2)(nil).WaitUntilLoadBalancerAvailableWithContext), arg0, arg1) } diff --git a/pkg/aws/services/rgt.go b/pkg/aws/services/rgt.go index 3231f0dd6b..28d52d9a1d 100644 --- a/pkg/aws/services/rgt.go +++ b/pkg/aws/services/rgt.go @@ -2,10 +2,9 @@ package services import ( "context" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi" - "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi/resourcegroupstaggingapiiface" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi" + rgttypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types" ) const ( @@ -14,41 +13,36 @@ const ( ) type RGT interface { - resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI - - GetResourcesAsList(ctx context.Context, input *resourcegroupstaggingapi.GetResourcesInput) ([]*resourcegroupstaggingapi.ResourceTagMapping, error) + GetResourcesAsList(ctx context.Context, input *resourcegroupstaggingapi.GetResourcesInput) ([]rgttypes.ResourceTagMapping, error) } // NewRGT constructs new RGT implementation. -func NewRGT(session *session.Session) RGT { - return &defaultRGT{ - ResourceGroupsTaggingAPIAPI: resourcegroupstaggingapi.New(session), - } +func NewRGT(cfg aws.Config) RGT { + client := resourcegroupstaggingapi.NewFromConfig(cfg) + return &rgtClient{rgtClient: client} } -var _ RGT = (*defaultRGT)(nil) - -type defaultRGT struct { - resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI +type rgtClient struct { + rgtClient *resourcegroupstaggingapi.Client } -func (c *defaultRGT) GetResourcesAsList(ctx context.Context, input *resourcegroupstaggingapi.GetResourcesInput) ([]*resourcegroupstaggingapi.ResourceTagMapping, error) { - var result []*resourcegroupstaggingapi.ResourceTagMapping - if err := c.GetResourcesPagesWithContext(ctx, input, func(output *resourcegroupstaggingapi.GetResourcesOutput, _ bool) bool { - for _, i := range output.ResourceTagMappingList { - result = append(result, i) +func (c *rgtClient) GetResourcesAsList(ctx context.Context, input *resourcegroupstaggingapi.GetResourcesInput) ([]rgttypes.ResourceTagMapping, error) { + var result []rgttypes.ResourceTagMapping + paginator := resourcegroupstaggingapi.NewGetResourcesPaginator(c.rgtClient, input) + for paginator.HasMorePages() { + output, err := paginator.NextPage(ctx) + if err != nil { + return nil, err } - return true - }); err != nil { - return nil, err + result = append(result, output.ResourceTagMappingList...) } return result, nil } -func ParseRGTTags(tags []*resourcegroupstaggingapi.Tag) map[string]string { +func ParseRGTTags(tags []rgttypes.Tag) map[string]string { result := make(map[string]string, len(tags)) for _, tag := range tags { - result[aws.StringValue(tag.Key)] = aws.StringValue(tag.Value) + result[aws.ToString(tag.Key)] = aws.ToString(tag.Value) } return result } diff --git a/pkg/aws/services/rgt_mocks.go b/pkg/aws/services/rgt_mocks.go new file mode 100644 index 0000000000..10ecbdfaf3 --- /dev/null +++ b/pkg/aws/services/rgt_mocks.go @@ -0,0 +1,52 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services (interfaces: RGT) + +// Package services is a generated GoMock package. +package services + +import ( + context "context" + reflect "reflect" + + resourcegroupstaggingapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi" + types "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types" + gomock "github.com/golang/mock/gomock" +) + +// MockRGT is a mock of RGT interface. +type MockRGT struct { + ctrl *gomock.Controller + recorder *MockRGTMockRecorder +} + +// MockRGTMockRecorder is the mock recorder for MockRGT. +type MockRGTMockRecorder struct { + mock *MockRGT +} + +// NewMockRGT creates a new mock instance. +func NewMockRGT(ctrl *gomock.Controller) *MockRGT { + mock := &MockRGT{ctrl: ctrl} + mock.recorder = &MockRGTMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockRGT) EXPECT() *MockRGTMockRecorder { + return m.recorder +} + +// GetResourcesAsList mocks base method. +func (m *MockRGT) GetResourcesAsList(arg0 context.Context, arg1 *resourcegroupstaggingapi.GetResourcesInput) ([]types.ResourceTagMapping, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetResourcesAsList", arg0, arg1) + ret0, _ := ret[0].([]types.ResourceTagMapping) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetResourcesAsList indicates an expected call of GetResourcesAsList. +func (mr *MockRGTMockRecorder) GetResourcesAsList(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesAsList", reflect.TypeOf((*MockRGT)(nil).GetResourcesAsList), arg0, arg1) +} diff --git a/pkg/aws/services/shield.go b/pkg/aws/services/shield.go index 03ef67d563..3247124396 100644 --- a/pkg/aws/services/shield.go +++ b/pkg/aws/services/shield.go @@ -1,25 +1,44 @@ package services import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/shield" - "github.com/aws/aws-sdk-go/service/shield/shieldiface" + "context" + "github.com/aws/aws-sdk-go-v2/aws" + shieldsdk "github.com/aws/aws-sdk-go-v2/service/shield" ) type Shield interface { - shieldiface.ShieldAPI + CreateProtectionWithContext(ctx context.Context, input *shieldsdk.CreateProtectionInput) (*shieldsdk.CreateProtectionOutput, error) + DeleteProtectionWithContext(ctx context.Context, input *shieldsdk.DeleteProtectionInput) (*shieldsdk.DeleteProtectionOutput, error) + DescribeProtectionWithContext(ctx context.Context, input *shieldsdk.DescribeProtectionInput) (*shieldsdk.DescribeProtectionOutput, error) + GetSubscriptionStateWithContext(ctx context.Context, input *shieldsdk.GetSubscriptionStateInput) (*shieldsdk.GetSubscriptionStateOutput, error) } // NewShield constructs new Shield implementation. -func NewShield(session *session.Session) Shield { - return &defaultShield{ - // shield is only available as a global API in us-east-1. - ShieldAPI: shield.New(session, aws.NewConfig().WithRegion("us-east-1")), - } +func NewShield(cfg aws.Config) Shield { + // shield is only available as a global API in us-east-1. + client := shieldsdk.NewFromConfig(cfg, func(o *shieldsdk.Options) { + o.Region = "us-east-1" + }) + return &shieldClient{shieldClient: client} } // default implementation for Shield. -type defaultShield struct { - shieldiface.ShieldAPI +type shieldClient struct { + shieldClient *shieldsdk.Client +} + +func (s *shieldClient) GetSubscriptionStateWithContext(ctx context.Context, input *shieldsdk.GetSubscriptionStateInput) (*shieldsdk.GetSubscriptionStateOutput, error) { + return s.shieldClient.GetSubscriptionState(ctx, input) +} + +func (s *shieldClient) DescribeProtectionWithContext(ctx context.Context, input *shieldsdk.DescribeProtectionInput) (*shieldsdk.DescribeProtectionOutput, error) { + return s.shieldClient.DescribeProtection(ctx, input) +} + +func (s *shieldClient) CreateProtectionWithContext(ctx context.Context, input *shieldsdk.CreateProtectionInput) (*shieldsdk.CreateProtectionOutput, error) { + return s.shieldClient.CreateProtection(ctx, input) +} + +func (s *shieldClient) DeleteProtectionWithContext(ctx context.Context, input *shieldsdk.DeleteProtectionInput) (*shieldsdk.DeleteProtectionOutput, error) { + return s.shieldClient.DeleteProtection(ctx, input) } diff --git a/pkg/aws/services/shield_mocks.go b/pkg/aws/services/shield_mocks.go index 782cf2a414..c9c78d4d66 100644 --- a/pkg/aws/services/shield_mocks.go +++ b/pkg/aws/services/shield_mocks.go @@ -8,8 +8,7 @@ import ( context "context" reflect "reflect" - request "github.com/aws/aws-sdk-go/aws/request" - shield "github.com/aws/aws-sdk-go/service/shield" + shield "github.com/aws/aws-sdk-go-v2/service/shield" gomock "github.com/golang/mock/gomock" ) @@ -36,1934 +35,62 @@ func (m *MockShield) EXPECT() *MockShieldMockRecorder { return m.recorder } -// AssociateDRTLogBucket mocks base method. -func (m *MockShield) AssociateDRTLogBucket(arg0 *shield.AssociateDRTLogBucketInput) (*shield.AssociateDRTLogBucketOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDRTLogBucket", arg0) - ret0, _ := ret[0].(*shield.AssociateDRTLogBucketOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDRTLogBucket indicates an expected call of AssociateDRTLogBucket. -func (mr *MockShieldMockRecorder) AssociateDRTLogBucket(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDRTLogBucket", reflect.TypeOf((*MockShield)(nil).AssociateDRTLogBucket), arg0) -} - -// AssociateDRTLogBucketRequest mocks base method. -func (m *MockShield) AssociateDRTLogBucketRequest(arg0 *shield.AssociateDRTLogBucketInput) (*request.Request, *shield.AssociateDRTLogBucketOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDRTLogBucketRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.AssociateDRTLogBucketOutput) - return ret0, ret1 -} - -// AssociateDRTLogBucketRequest indicates an expected call of AssociateDRTLogBucketRequest. -func (mr *MockShieldMockRecorder) AssociateDRTLogBucketRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDRTLogBucketRequest", reflect.TypeOf((*MockShield)(nil).AssociateDRTLogBucketRequest), arg0) -} - -// AssociateDRTLogBucketWithContext mocks base method. -func (m *MockShield) AssociateDRTLogBucketWithContext(arg0 context.Context, arg1 *shield.AssociateDRTLogBucketInput, arg2 ...request.Option) (*shield.AssociateDRTLogBucketOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateDRTLogBucketWithContext", varargs...) - ret0, _ := ret[0].(*shield.AssociateDRTLogBucketOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDRTLogBucketWithContext indicates an expected call of AssociateDRTLogBucketWithContext. -func (mr *MockShieldMockRecorder) AssociateDRTLogBucketWithContext(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, "AssociateDRTLogBucketWithContext", reflect.TypeOf((*MockShield)(nil).AssociateDRTLogBucketWithContext), varargs...) -} - -// AssociateDRTRole mocks base method. -func (m *MockShield) AssociateDRTRole(arg0 *shield.AssociateDRTRoleInput) (*shield.AssociateDRTRoleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDRTRole", arg0) - ret0, _ := ret[0].(*shield.AssociateDRTRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDRTRole indicates an expected call of AssociateDRTRole. -func (mr *MockShieldMockRecorder) AssociateDRTRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDRTRole", reflect.TypeOf((*MockShield)(nil).AssociateDRTRole), arg0) -} - -// AssociateDRTRoleRequest mocks base method. -func (m *MockShield) AssociateDRTRoleRequest(arg0 *shield.AssociateDRTRoleInput) (*request.Request, *shield.AssociateDRTRoleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateDRTRoleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.AssociateDRTRoleOutput) - return ret0, ret1 -} - -// AssociateDRTRoleRequest indicates an expected call of AssociateDRTRoleRequest. -func (mr *MockShieldMockRecorder) AssociateDRTRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDRTRoleRequest", reflect.TypeOf((*MockShield)(nil).AssociateDRTRoleRequest), arg0) -} - -// AssociateDRTRoleWithContext mocks base method. -func (m *MockShield) AssociateDRTRoleWithContext(arg0 context.Context, arg1 *shield.AssociateDRTRoleInput, arg2 ...request.Option) (*shield.AssociateDRTRoleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateDRTRoleWithContext", varargs...) - ret0, _ := ret[0].(*shield.AssociateDRTRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateDRTRoleWithContext indicates an expected call of AssociateDRTRoleWithContext. -func (mr *MockShieldMockRecorder) AssociateDRTRoleWithContext(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, "AssociateDRTRoleWithContext", reflect.TypeOf((*MockShield)(nil).AssociateDRTRoleWithContext), varargs...) -} - -// AssociateHealthCheck mocks base method. -func (m *MockShield) AssociateHealthCheck(arg0 *shield.AssociateHealthCheckInput) (*shield.AssociateHealthCheckOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateHealthCheck", arg0) - ret0, _ := ret[0].(*shield.AssociateHealthCheckOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateHealthCheck indicates an expected call of AssociateHealthCheck. -func (mr *MockShieldMockRecorder) AssociateHealthCheck(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateHealthCheck", reflect.TypeOf((*MockShield)(nil).AssociateHealthCheck), arg0) -} - -// AssociateHealthCheckRequest mocks base method. -func (m *MockShield) AssociateHealthCheckRequest(arg0 *shield.AssociateHealthCheckInput) (*request.Request, *shield.AssociateHealthCheckOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateHealthCheckRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.AssociateHealthCheckOutput) - return ret0, ret1 -} - -// AssociateHealthCheckRequest indicates an expected call of AssociateHealthCheckRequest. -func (mr *MockShieldMockRecorder) AssociateHealthCheckRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateHealthCheckRequest", reflect.TypeOf((*MockShield)(nil).AssociateHealthCheckRequest), arg0) -} - -// AssociateHealthCheckWithContext mocks base method. -func (m *MockShield) AssociateHealthCheckWithContext(arg0 context.Context, arg1 *shield.AssociateHealthCheckInput, arg2 ...request.Option) (*shield.AssociateHealthCheckOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateHealthCheckWithContext", varargs...) - ret0, _ := ret[0].(*shield.AssociateHealthCheckOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateHealthCheckWithContext indicates an expected call of AssociateHealthCheckWithContext. -func (mr *MockShieldMockRecorder) AssociateHealthCheckWithContext(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, "AssociateHealthCheckWithContext", reflect.TypeOf((*MockShield)(nil).AssociateHealthCheckWithContext), varargs...) -} - -// AssociateProactiveEngagementDetails mocks base method. -func (m *MockShield) AssociateProactiveEngagementDetails(arg0 *shield.AssociateProactiveEngagementDetailsInput) (*shield.AssociateProactiveEngagementDetailsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateProactiveEngagementDetails", arg0) - ret0, _ := ret[0].(*shield.AssociateProactiveEngagementDetailsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateProactiveEngagementDetails indicates an expected call of AssociateProactiveEngagementDetails. -func (mr *MockShieldMockRecorder) AssociateProactiveEngagementDetails(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateProactiveEngagementDetails", reflect.TypeOf((*MockShield)(nil).AssociateProactiveEngagementDetails), arg0) -} - -// AssociateProactiveEngagementDetailsRequest mocks base method. -func (m *MockShield) AssociateProactiveEngagementDetailsRequest(arg0 *shield.AssociateProactiveEngagementDetailsInput) (*request.Request, *shield.AssociateProactiveEngagementDetailsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "AssociateProactiveEngagementDetailsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.AssociateProactiveEngagementDetailsOutput) - return ret0, ret1 -} - -// AssociateProactiveEngagementDetailsRequest indicates an expected call of AssociateProactiveEngagementDetailsRequest. -func (mr *MockShieldMockRecorder) AssociateProactiveEngagementDetailsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateProactiveEngagementDetailsRequest", reflect.TypeOf((*MockShield)(nil).AssociateProactiveEngagementDetailsRequest), arg0) -} - -// AssociateProactiveEngagementDetailsWithContext mocks base method. -func (m *MockShield) AssociateProactiveEngagementDetailsWithContext(arg0 context.Context, arg1 *shield.AssociateProactiveEngagementDetailsInput, arg2 ...request.Option) (*shield.AssociateProactiveEngagementDetailsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "AssociateProactiveEngagementDetailsWithContext", varargs...) - ret0, _ := ret[0].(*shield.AssociateProactiveEngagementDetailsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// AssociateProactiveEngagementDetailsWithContext indicates an expected call of AssociateProactiveEngagementDetailsWithContext. -func (mr *MockShieldMockRecorder) AssociateProactiveEngagementDetailsWithContext(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, "AssociateProactiveEngagementDetailsWithContext", reflect.TypeOf((*MockShield)(nil).AssociateProactiveEngagementDetailsWithContext), varargs...) -} - -// CreateProtection mocks base method. -func (m *MockShield) CreateProtection(arg0 *shield.CreateProtectionInput) (*shield.CreateProtectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateProtection", arg0) - ret0, _ := ret[0].(*shield.CreateProtectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateProtection indicates an expected call of CreateProtection. -func (mr *MockShieldMockRecorder) CreateProtection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtection", reflect.TypeOf((*MockShield)(nil).CreateProtection), arg0) -} - -// CreateProtectionGroup mocks base method. -func (m *MockShield) CreateProtectionGroup(arg0 *shield.CreateProtectionGroupInput) (*shield.CreateProtectionGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateProtectionGroup", arg0) - ret0, _ := ret[0].(*shield.CreateProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateProtectionGroup indicates an expected call of CreateProtectionGroup. -func (mr *MockShieldMockRecorder) CreateProtectionGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectionGroup", reflect.TypeOf((*MockShield)(nil).CreateProtectionGroup), arg0) -} - -// CreateProtectionGroupRequest mocks base method. -func (m *MockShield) CreateProtectionGroupRequest(arg0 *shield.CreateProtectionGroupInput) (*request.Request, *shield.CreateProtectionGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateProtectionGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.CreateProtectionGroupOutput) - return ret0, ret1 -} - -// CreateProtectionGroupRequest indicates an expected call of CreateProtectionGroupRequest. -func (mr *MockShieldMockRecorder) CreateProtectionGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectionGroupRequest", reflect.TypeOf((*MockShield)(nil).CreateProtectionGroupRequest), arg0) -} - -// CreateProtectionGroupWithContext mocks base method. -func (m *MockShield) CreateProtectionGroupWithContext(arg0 context.Context, arg1 *shield.CreateProtectionGroupInput, arg2 ...request.Option) (*shield.CreateProtectionGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateProtectionGroupWithContext", varargs...) - ret0, _ := ret[0].(*shield.CreateProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateProtectionGroupWithContext indicates an expected call of CreateProtectionGroupWithContext. -func (mr *MockShieldMockRecorder) CreateProtectionGroupWithContext(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, "CreateProtectionGroupWithContext", reflect.TypeOf((*MockShield)(nil).CreateProtectionGroupWithContext), varargs...) -} - -// CreateProtectionRequest mocks base method. -func (m *MockShield) CreateProtectionRequest(arg0 *shield.CreateProtectionInput) (*request.Request, *shield.CreateProtectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateProtectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.CreateProtectionOutput) - return ret0, ret1 -} - -// CreateProtectionRequest indicates an expected call of CreateProtectionRequest. -func (mr *MockShieldMockRecorder) CreateProtectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectionRequest", reflect.TypeOf((*MockShield)(nil).CreateProtectionRequest), arg0) -} - // CreateProtectionWithContext mocks base method. -func (m *MockShield) CreateProtectionWithContext(arg0 context.Context, arg1 *shield.CreateProtectionInput, arg2 ...request.Option) (*shield.CreateProtectionOutput, error) { +func (m *MockShield) CreateProtectionWithContext(arg0 context.Context, arg1 *shield.CreateProtectionInput) (*shield.CreateProtectionOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateProtectionWithContext", varargs...) + ret := m.ctrl.Call(m, "CreateProtectionWithContext", arg0, arg1) ret0, _ := ret[0].(*shield.CreateProtectionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateProtectionWithContext indicates an expected call of CreateProtectionWithContext. -func (mr *MockShieldMockRecorder) CreateProtectionWithContext(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, "CreateProtectionWithContext", reflect.TypeOf((*MockShield)(nil).CreateProtectionWithContext), varargs...) -} - -// CreateSubscription mocks base method. -func (m *MockShield) CreateSubscription(arg0 *shield.CreateSubscriptionInput) (*shield.CreateSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubscription", arg0) - ret0, _ := ret[0].(*shield.CreateSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubscription indicates an expected call of CreateSubscription. -func (mr *MockShieldMockRecorder) CreateSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscription", reflect.TypeOf((*MockShield)(nil).CreateSubscription), arg0) -} - -// CreateSubscriptionRequest mocks base method. -func (m *MockShield) CreateSubscriptionRequest(arg0 *shield.CreateSubscriptionInput) (*request.Request, *shield.CreateSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreateSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.CreateSubscriptionOutput) - return ret0, ret1 -} - -// CreateSubscriptionRequest indicates an expected call of CreateSubscriptionRequest. -func (mr *MockShieldMockRecorder) CreateSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscriptionRequest", reflect.TypeOf((*MockShield)(nil).CreateSubscriptionRequest), arg0) -} - -// CreateSubscriptionWithContext mocks base method. -func (m *MockShield) CreateSubscriptionWithContext(arg0 context.Context, arg1 *shield.CreateSubscriptionInput, arg2 ...request.Option) (*shield.CreateSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "CreateSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*shield.CreateSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// CreateSubscriptionWithContext indicates an expected call of CreateSubscriptionWithContext. -func (mr *MockShieldMockRecorder) CreateSubscriptionWithContext(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, "CreateSubscriptionWithContext", reflect.TypeOf((*MockShield)(nil).CreateSubscriptionWithContext), varargs...) -} - -// DeleteProtection mocks base method. -func (m *MockShield) DeleteProtection(arg0 *shield.DeleteProtectionInput) (*shield.DeleteProtectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteProtection", arg0) - ret0, _ := ret[0].(*shield.DeleteProtectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteProtection indicates an expected call of DeleteProtection. -func (mr *MockShieldMockRecorder) DeleteProtection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtection", reflect.TypeOf((*MockShield)(nil).DeleteProtection), arg0) -} - -// DeleteProtectionGroup mocks base method. -func (m *MockShield) DeleteProtectionGroup(arg0 *shield.DeleteProtectionGroupInput) (*shield.DeleteProtectionGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteProtectionGroup", arg0) - ret0, _ := ret[0].(*shield.DeleteProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteProtectionGroup indicates an expected call of DeleteProtectionGroup. -func (mr *MockShieldMockRecorder) DeleteProtectionGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectionGroup", reflect.TypeOf((*MockShield)(nil).DeleteProtectionGroup), arg0) -} - -// DeleteProtectionGroupRequest mocks base method. -func (m *MockShield) DeleteProtectionGroupRequest(arg0 *shield.DeleteProtectionGroupInput) (*request.Request, *shield.DeleteProtectionGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteProtectionGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DeleteProtectionGroupOutput) - return ret0, ret1 -} - -// DeleteProtectionGroupRequest indicates an expected call of DeleteProtectionGroupRequest. -func (mr *MockShieldMockRecorder) DeleteProtectionGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectionGroupRequest", reflect.TypeOf((*MockShield)(nil).DeleteProtectionGroupRequest), arg0) -} - -// DeleteProtectionGroupWithContext mocks base method. -func (m *MockShield) DeleteProtectionGroupWithContext(arg0 context.Context, arg1 *shield.DeleteProtectionGroupInput, arg2 ...request.Option) (*shield.DeleteProtectionGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteProtectionGroupWithContext", varargs...) - ret0, _ := ret[0].(*shield.DeleteProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteProtectionGroupWithContext indicates an expected call of DeleteProtectionGroupWithContext. -func (mr *MockShieldMockRecorder) DeleteProtectionGroupWithContext(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, "DeleteProtectionGroupWithContext", reflect.TypeOf((*MockShield)(nil).DeleteProtectionGroupWithContext), varargs...) -} - -// DeleteProtectionRequest mocks base method. -func (m *MockShield) DeleteProtectionRequest(arg0 *shield.DeleteProtectionInput) (*request.Request, *shield.DeleteProtectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteProtectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DeleteProtectionOutput) - return ret0, ret1 -} - -// DeleteProtectionRequest indicates an expected call of DeleteProtectionRequest. -func (mr *MockShieldMockRecorder) DeleteProtectionRequest(arg0 interface{}) *gomock.Call { +func (mr *MockShieldMockRecorder) CreateProtectionWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectionRequest", reflect.TypeOf((*MockShield)(nil).DeleteProtectionRequest), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProtectionWithContext", reflect.TypeOf((*MockShield)(nil).CreateProtectionWithContext), arg0, arg1) } // DeleteProtectionWithContext mocks base method. -func (m *MockShield) DeleteProtectionWithContext(arg0 context.Context, arg1 *shield.DeleteProtectionInput, arg2 ...request.Option) (*shield.DeleteProtectionOutput, error) { +func (m *MockShield) DeleteProtectionWithContext(arg0 context.Context, arg1 *shield.DeleteProtectionInput) (*shield.DeleteProtectionOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteProtectionWithContext", varargs...) + ret := m.ctrl.Call(m, "DeleteProtectionWithContext", arg0, arg1) ret0, _ := ret[0].(*shield.DeleteProtectionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteProtectionWithContext indicates an expected call of DeleteProtectionWithContext. -func (mr *MockShieldMockRecorder) DeleteProtectionWithContext(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, "DeleteProtectionWithContext", reflect.TypeOf((*MockShield)(nil).DeleteProtectionWithContext), varargs...) -} - -// DeleteSubscription mocks base method. -func (m *MockShield) DeleteSubscription(arg0 *shield.DeleteSubscriptionInput) (*shield.DeleteSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubscription", arg0) - ret0, _ := ret[0].(*shield.DeleteSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubscription indicates an expected call of DeleteSubscription. -func (mr *MockShieldMockRecorder) DeleteSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubscription", reflect.TypeOf((*MockShield)(nil).DeleteSubscription), arg0) -} - -// DeleteSubscriptionRequest mocks base method. -func (m *MockShield) DeleteSubscriptionRequest(arg0 *shield.DeleteSubscriptionInput) (*request.Request, *shield.DeleteSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DeleteSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DeleteSubscriptionOutput) - return ret0, ret1 -} - -// DeleteSubscriptionRequest indicates an expected call of DeleteSubscriptionRequest. -func (mr *MockShieldMockRecorder) DeleteSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubscriptionRequest", reflect.TypeOf((*MockShield)(nil).DeleteSubscriptionRequest), arg0) -} - -// DeleteSubscriptionWithContext mocks base method. -func (m *MockShield) DeleteSubscriptionWithContext(arg0 context.Context, arg1 *shield.DeleteSubscriptionInput, arg2 ...request.Option) (*shield.DeleteSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DeleteSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*shield.DeleteSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DeleteSubscriptionWithContext indicates an expected call of DeleteSubscriptionWithContext. -func (mr *MockShieldMockRecorder) DeleteSubscriptionWithContext(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, "DeleteSubscriptionWithContext", reflect.TypeOf((*MockShield)(nil).DeleteSubscriptionWithContext), varargs...) -} - -// DescribeAttack mocks base method. -func (m *MockShield) DescribeAttack(arg0 *shield.DescribeAttackInput) (*shield.DescribeAttackOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAttack", arg0) - ret0, _ := ret[0].(*shield.DescribeAttackOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAttack indicates an expected call of DescribeAttack. -func (mr *MockShieldMockRecorder) DescribeAttack(arg0 interface{}) *gomock.Call { +func (mr *MockShieldMockRecorder) DeleteProtectionWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttack", reflect.TypeOf((*MockShield)(nil).DescribeAttack), arg0) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProtectionWithContext", reflect.TypeOf((*MockShield)(nil).DeleteProtectionWithContext), arg0, arg1) } -// DescribeAttackRequest mocks base method. -func (m *MockShield) DescribeAttackRequest(arg0 *shield.DescribeAttackInput) (*request.Request, *shield.DescribeAttackOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAttackRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeAttackOutput) - return ret0, ret1 -} - -// DescribeAttackRequest indicates an expected call of DescribeAttackRequest. -func (mr *MockShieldMockRecorder) DescribeAttackRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttackRequest", reflect.TypeOf((*MockShield)(nil).DescribeAttackRequest), arg0) -} - -// DescribeAttackStatistics mocks base method. -func (m *MockShield) DescribeAttackStatistics(arg0 *shield.DescribeAttackStatisticsInput) (*shield.DescribeAttackStatisticsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAttackStatistics", arg0) - ret0, _ := ret[0].(*shield.DescribeAttackStatisticsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeAttackStatistics indicates an expected call of DescribeAttackStatistics. -func (mr *MockShieldMockRecorder) DescribeAttackStatistics(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttackStatistics", reflect.TypeOf((*MockShield)(nil).DescribeAttackStatistics), arg0) -} - -// DescribeAttackStatisticsRequest mocks base method. -func (m *MockShield) DescribeAttackStatisticsRequest(arg0 *shield.DescribeAttackStatisticsInput) (*request.Request, *shield.DescribeAttackStatisticsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeAttackStatisticsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeAttackStatisticsOutput) - return ret0, ret1 -} - -// DescribeAttackStatisticsRequest indicates an expected call of DescribeAttackStatisticsRequest. -func (mr *MockShieldMockRecorder) DescribeAttackStatisticsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttackStatisticsRequest", reflect.TypeOf((*MockShield)(nil).DescribeAttackStatisticsRequest), arg0) -} - -// DescribeAttackStatisticsWithContext mocks base method. -func (m *MockShield) DescribeAttackStatisticsWithContext(arg0 context.Context, arg1 *shield.DescribeAttackStatisticsInput, arg2 ...request.Option) (*shield.DescribeAttackStatisticsOutput, error) { +// DescribeProtectionWithContext mocks base method. +func (m *MockShield) DescribeProtectionWithContext(arg0 context.Context, arg1 *shield.DescribeProtectionInput) (*shield.DescribeProtectionOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAttackStatisticsWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeAttackStatisticsOutput) + ret := m.ctrl.Call(m, "DescribeProtectionWithContext", arg0, arg1) + ret0, _ := ret[0].(*shield.DescribeProtectionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAttackStatisticsWithContext indicates an expected call of DescribeAttackStatisticsWithContext. -func (mr *MockShieldMockRecorder) DescribeAttackStatisticsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// DescribeProtectionWithContext indicates an expected call of DescribeProtectionWithContext. +func (mr *MockShieldMockRecorder) DescribeProtectionWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAttackStatisticsWithContext", reflect.TypeOf((*MockShield)(nil).DescribeAttackStatisticsWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectionWithContext", reflect.TypeOf((*MockShield)(nil).DescribeProtectionWithContext), arg0, arg1) } -// DescribeAttackWithContext mocks base method. -func (m *MockShield) DescribeAttackWithContext(arg0 context.Context, arg1 *shield.DescribeAttackInput, arg2 ...request.Option) (*shield.DescribeAttackOutput, error) { +// GetSubscriptionStateWithContext mocks base method. +func (m *MockShield) GetSubscriptionStateWithContext(arg0 context.Context, arg1 *shield.GetSubscriptionStateInput) (*shield.GetSubscriptionStateOutput, error) { m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeAttackWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeAttackOutput) + ret := m.ctrl.Call(m, "GetSubscriptionStateWithContext", arg0, arg1) + ret0, _ := ret[0].(*shield.GetSubscriptionStateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } -// DescribeAttackWithContext indicates an expected call of DescribeAttackWithContext. -func (mr *MockShieldMockRecorder) DescribeAttackWithContext(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, "DescribeAttackWithContext", reflect.TypeOf((*MockShield)(nil).DescribeAttackWithContext), varargs...) -} - -// DescribeDRTAccess mocks base method. -func (m *MockShield) DescribeDRTAccess(arg0 *shield.DescribeDRTAccessInput) (*shield.DescribeDRTAccessOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDRTAccess", arg0) - ret0, _ := ret[0].(*shield.DescribeDRTAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDRTAccess indicates an expected call of DescribeDRTAccess. -func (mr *MockShieldMockRecorder) DescribeDRTAccess(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDRTAccess", reflect.TypeOf((*MockShield)(nil).DescribeDRTAccess), arg0) -} - -// DescribeDRTAccessRequest mocks base method. -func (m *MockShield) DescribeDRTAccessRequest(arg0 *shield.DescribeDRTAccessInput) (*request.Request, *shield.DescribeDRTAccessOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeDRTAccessRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeDRTAccessOutput) - return ret0, ret1 -} - -// DescribeDRTAccessRequest indicates an expected call of DescribeDRTAccessRequest. -func (mr *MockShieldMockRecorder) DescribeDRTAccessRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDRTAccessRequest", reflect.TypeOf((*MockShield)(nil).DescribeDRTAccessRequest), arg0) -} - -// DescribeDRTAccessWithContext mocks base method. -func (m *MockShield) DescribeDRTAccessWithContext(arg0 context.Context, arg1 *shield.DescribeDRTAccessInput, arg2 ...request.Option) (*shield.DescribeDRTAccessOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeDRTAccessWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeDRTAccessOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeDRTAccessWithContext indicates an expected call of DescribeDRTAccessWithContext. -func (mr *MockShieldMockRecorder) DescribeDRTAccessWithContext(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, "DescribeDRTAccessWithContext", reflect.TypeOf((*MockShield)(nil).DescribeDRTAccessWithContext), varargs...) -} - -// DescribeEmergencyContactSettings mocks base method. -func (m *MockShield) DescribeEmergencyContactSettings(arg0 *shield.DescribeEmergencyContactSettingsInput) (*shield.DescribeEmergencyContactSettingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEmergencyContactSettings", arg0) - ret0, _ := ret[0].(*shield.DescribeEmergencyContactSettingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEmergencyContactSettings indicates an expected call of DescribeEmergencyContactSettings. -func (mr *MockShieldMockRecorder) DescribeEmergencyContactSettings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEmergencyContactSettings", reflect.TypeOf((*MockShield)(nil).DescribeEmergencyContactSettings), arg0) -} - -// DescribeEmergencyContactSettingsRequest mocks base method. -func (m *MockShield) DescribeEmergencyContactSettingsRequest(arg0 *shield.DescribeEmergencyContactSettingsInput) (*request.Request, *shield.DescribeEmergencyContactSettingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeEmergencyContactSettingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeEmergencyContactSettingsOutput) - return ret0, ret1 -} - -// DescribeEmergencyContactSettingsRequest indicates an expected call of DescribeEmergencyContactSettingsRequest. -func (mr *MockShieldMockRecorder) DescribeEmergencyContactSettingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEmergencyContactSettingsRequest", reflect.TypeOf((*MockShield)(nil).DescribeEmergencyContactSettingsRequest), arg0) -} - -// DescribeEmergencyContactSettingsWithContext mocks base method. -func (m *MockShield) DescribeEmergencyContactSettingsWithContext(arg0 context.Context, arg1 *shield.DescribeEmergencyContactSettingsInput, arg2 ...request.Option) (*shield.DescribeEmergencyContactSettingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeEmergencyContactSettingsWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeEmergencyContactSettingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeEmergencyContactSettingsWithContext indicates an expected call of DescribeEmergencyContactSettingsWithContext. -func (mr *MockShieldMockRecorder) DescribeEmergencyContactSettingsWithContext(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, "DescribeEmergencyContactSettingsWithContext", reflect.TypeOf((*MockShield)(nil).DescribeEmergencyContactSettingsWithContext), varargs...) -} - -// DescribeProtection mocks base method. -func (m *MockShield) DescribeProtection(arg0 *shield.DescribeProtectionInput) (*shield.DescribeProtectionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeProtection", arg0) - ret0, _ := ret[0].(*shield.DescribeProtectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeProtection indicates an expected call of DescribeProtection. -func (mr *MockShieldMockRecorder) DescribeProtection(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtection", reflect.TypeOf((*MockShield)(nil).DescribeProtection), arg0) -} - -// DescribeProtectionGroup mocks base method. -func (m *MockShield) DescribeProtectionGroup(arg0 *shield.DescribeProtectionGroupInput) (*shield.DescribeProtectionGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeProtectionGroup", arg0) - ret0, _ := ret[0].(*shield.DescribeProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeProtectionGroup indicates an expected call of DescribeProtectionGroup. -func (mr *MockShieldMockRecorder) DescribeProtectionGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectionGroup", reflect.TypeOf((*MockShield)(nil).DescribeProtectionGroup), arg0) -} - -// DescribeProtectionGroupRequest mocks base method. -func (m *MockShield) DescribeProtectionGroupRequest(arg0 *shield.DescribeProtectionGroupInput) (*request.Request, *shield.DescribeProtectionGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeProtectionGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeProtectionGroupOutput) - return ret0, ret1 -} - -// DescribeProtectionGroupRequest indicates an expected call of DescribeProtectionGroupRequest. -func (mr *MockShieldMockRecorder) DescribeProtectionGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectionGroupRequest", reflect.TypeOf((*MockShield)(nil).DescribeProtectionGroupRequest), arg0) -} - -// DescribeProtectionGroupWithContext mocks base method. -func (m *MockShield) DescribeProtectionGroupWithContext(arg0 context.Context, arg1 *shield.DescribeProtectionGroupInput, arg2 ...request.Option) (*shield.DescribeProtectionGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeProtectionGroupWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeProtectionGroupWithContext indicates an expected call of DescribeProtectionGroupWithContext. -func (mr *MockShieldMockRecorder) DescribeProtectionGroupWithContext(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, "DescribeProtectionGroupWithContext", reflect.TypeOf((*MockShield)(nil).DescribeProtectionGroupWithContext), varargs...) -} - -// DescribeProtectionRequest mocks base method. -func (m *MockShield) DescribeProtectionRequest(arg0 *shield.DescribeProtectionInput) (*request.Request, *shield.DescribeProtectionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeProtectionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeProtectionOutput) - return ret0, ret1 -} - -// DescribeProtectionRequest indicates an expected call of DescribeProtectionRequest. -func (mr *MockShieldMockRecorder) DescribeProtectionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeProtectionRequest", reflect.TypeOf((*MockShield)(nil).DescribeProtectionRequest), arg0) -} - -// DescribeProtectionWithContext mocks base method. -func (m *MockShield) DescribeProtectionWithContext(arg0 context.Context, arg1 *shield.DescribeProtectionInput, arg2 ...request.Option) (*shield.DescribeProtectionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeProtectionWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeProtectionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeProtectionWithContext indicates an expected call of DescribeProtectionWithContext. -func (mr *MockShieldMockRecorder) DescribeProtectionWithContext(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, "DescribeProtectionWithContext", reflect.TypeOf((*MockShield)(nil).DescribeProtectionWithContext), varargs...) -} - -// DescribeSubscription mocks base method. -func (m *MockShield) DescribeSubscription(arg0 *shield.DescribeSubscriptionInput) (*shield.DescribeSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubscription", arg0) - ret0, _ := ret[0].(*shield.DescribeSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSubscription indicates an expected call of DescribeSubscription. -func (mr *MockShieldMockRecorder) DescribeSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubscription", reflect.TypeOf((*MockShield)(nil).DescribeSubscription), arg0) -} - -// DescribeSubscriptionRequest mocks base method. -func (m *MockShield) DescribeSubscriptionRequest(arg0 *shield.DescribeSubscriptionInput) (*request.Request, *shield.DescribeSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DescribeSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DescribeSubscriptionOutput) - return ret0, ret1 -} - -// DescribeSubscriptionRequest indicates an expected call of DescribeSubscriptionRequest. -func (mr *MockShieldMockRecorder) DescribeSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubscriptionRequest", reflect.TypeOf((*MockShield)(nil).DescribeSubscriptionRequest), arg0) -} - -// DescribeSubscriptionWithContext mocks base method. -func (m *MockShield) DescribeSubscriptionWithContext(arg0 context.Context, arg1 *shield.DescribeSubscriptionInput, arg2 ...request.Option) (*shield.DescribeSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DescribeSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*shield.DescribeSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DescribeSubscriptionWithContext indicates an expected call of DescribeSubscriptionWithContext. -func (mr *MockShieldMockRecorder) DescribeSubscriptionWithContext(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, "DescribeSubscriptionWithContext", reflect.TypeOf((*MockShield)(nil).DescribeSubscriptionWithContext), varargs...) -} - -// DisableApplicationLayerAutomaticResponse mocks base method. -func (m *MockShield) DisableApplicationLayerAutomaticResponse(arg0 *shield.DisableApplicationLayerAutomaticResponseInput) (*shield.DisableApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableApplicationLayerAutomaticResponse", arg0) - ret0, _ := ret[0].(*shield.DisableApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableApplicationLayerAutomaticResponse indicates an expected call of DisableApplicationLayerAutomaticResponse. -func (mr *MockShieldMockRecorder) DisableApplicationLayerAutomaticResponse(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableApplicationLayerAutomaticResponse", reflect.TypeOf((*MockShield)(nil).DisableApplicationLayerAutomaticResponse), arg0) -} - -// DisableApplicationLayerAutomaticResponseRequest mocks base method. -func (m *MockShield) DisableApplicationLayerAutomaticResponseRequest(arg0 *shield.DisableApplicationLayerAutomaticResponseInput) (*request.Request, *shield.DisableApplicationLayerAutomaticResponseOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableApplicationLayerAutomaticResponseRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DisableApplicationLayerAutomaticResponseOutput) - return ret0, ret1 -} - -// DisableApplicationLayerAutomaticResponseRequest indicates an expected call of DisableApplicationLayerAutomaticResponseRequest. -func (mr *MockShieldMockRecorder) DisableApplicationLayerAutomaticResponseRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableApplicationLayerAutomaticResponseRequest", reflect.TypeOf((*MockShield)(nil).DisableApplicationLayerAutomaticResponseRequest), arg0) -} - -// DisableApplicationLayerAutomaticResponseWithContext mocks base method. -func (m *MockShield) DisableApplicationLayerAutomaticResponseWithContext(arg0 context.Context, arg1 *shield.DisableApplicationLayerAutomaticResponseInput, arg2 ...request.Option) (*shield.DisableApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableApplicationLayerAutomaticResponseWithContext", varargs...) - ret0, _ := ret[0].(*shield.DisableApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableApplicationLayerAutomaticResponseWithContext indicates an expected call of DisableApplicationLayerAutomaticResponseWithContext. -func (mr *MockShieldMockRecorder) DisableApplicationLayerAutomaticResponseWithContext(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, "DisableApplicationLayerAutomaticResponseWithContext", reflect.TypeOf((*MockShield)(nil).DisableApplicationLayerAutomaticResponseWithContext), varargs...) -} - -// DisableProactiveEngagement mocks base method. -func (m *MockShield) DisableProactiveEngagement(arg0 *shield.DisableProactiveEngagementInput) (*shield.DisableProactiveEngagementOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableProactiveEngagement", arg0) - ret0, _ := ret[0].(*shield.DisableProactiveEngagementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableProactiveEngagement indicates an expected call of DisableProactiveEngagement. -func (mr *MockShieldMockRecorder) DisableProactiveEngagement(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableProactiveEngagement", reflect.TypeOf((*MockShield)(nil).DisableProactiveEngagement), arg0) -} - -// DisableProactiveEngagementRequest mocks base method. -func (m *MockShield) DisableProactiveEngagementRequest(arg0 *shield.DisableProactiveEngagementInput) (*request.Request, *shield.DisableProactiveEngagementOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisableProactiveEngagementRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DisableProactiveEngagementOutput) - return ret0, ret1 -} - -// DisableProactiveEngagementRequest indicates an expected call of DisableProactiveEngagementRequest. -func (mr *MockShieldMockRecorder) DisableProactiveEngagementRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableProactiveEngagementRequest", reflect.TypeOf((*MockShield)(nil).DisableProactiveEngagementRequest), arg0) -} - -// DisableProactiveEngagementWithContext mocks base method. -func (m *MockShield) DisableProactiveEngagementWithContext(arg0 context.Context, arg1 *shield.DisableProactiveEngagementInput, arg2 ...request.Option) (*shield.DisableProactiveEngagementOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisableProactiveEngagementWithContext", varargs...) - ret0, _ := ret[0].(*shield.DisableProactiveEngagementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisableProactiveEngagementWithContext indicates an expected call of DisableProactiveEngagementWithContext. -func (mr *MockShieldMockRecorder) DisableProactiveEngagementWithContext(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, "DisableProactiveEngagementWithContext", reflect.TypeOf((*MockShield)(nil).DisableProactiveEngagementWithContext), varargs...) -} - -// DisassociateDRTLogBucket mocks base method. -func (m *MockShield) DisassociateDRTLogBucket(arg0 *shield.DisassociateDRTLogBucketInput) (*shield.DisassociateDRTLogBucketOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateDRTLogBucket", arg0) - ret0, _ := ret[0].(*shield.DisassociateDRTLogBucketOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateDRTLogBucket indicates an expected call of DisassociateDRTLogBucket. -func (mr *MockShieldMockRecorder) DisassociateDRTLogBucket(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateDRTLogBucket", reflect.TypeOf((*MockShield)(nil).DisassociateDRTLogBucket), arg0) -} - -// DisassociateDRTLogBucketRequest mocks base method. -func (m *MockShield) DisassociateDRTLogBucketRequest(arg0 *shield.DisassociateDRTLogBucketInput) (*request.Request, *shield.DisassociateDRTLogBucketOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateDRTLogBucketRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DisassociateDRTLogBucketOutput) - return ret0, ret1 -} - -// DisassociateDRTLogBucketRequest indicates an expected call of DisassociateDRTLogBucketRequest. -func (mr *MockShieldMockRecorder) DisassociateDRTLogBucketRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateDRTLogBucketRequest", reflect.TypeOf((*MockShield)(nil).DisassociateDRTLogBucketRequest), arg0) -} - -// DisassociateDRTLogBucketWithContext mocks base method. -func (m *MockShield) DisassociateDRTLogBucketWithContext(arg0 context.Context, arg1 *shield.DisassociateDRTLogBucketInput, arg2 ...request.Option) (*shield.DisassociateDRTLogBucketOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateDRTLogBucketWithContext", varargs...) - ret0, _ := ret[0].(*shield.DisassociateDRTLogBucketOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateDRTLogBucketWithContext indicates an expected call of DisassociateDRTLogBucketWithContext. -func (mr *MockShieldMockRecorder) DisassociateDRTLogBucketWithContext(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, "DisassociateDRTLogBucketWithContext", reflect.TypeOf((*MockShield)(nil).DisassociateDRTLogBucketWithContext), varargs...) -} - -// DisassociateDRTRole mocks base method. -func (m *MockShield) DisassociateDRTRole(arg0 *shield.DisassociateDRTRoleInput) (*shield.DisassociateDRTRoleOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateDRTRole", arg0) - ret0, _ := ret[0].(*shield.DisassociateDRTRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateDRTRole indicates an expected call of DisassociateDRTRole. -func (mr *MockShieldMockRecorder) DisassociateDRTRole(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateDRTRole", reflect.TypeOf((*MockShield)(nil).DisassociateDRTRole), arg0) -} - -// DisassociateDRTRoleRequest mocks base method. -func (m *MockShield) DisassociateDRTRoleRequest(arg0 *shield.DisassociateDRTRoleInput) (*request.Request, *shield.DisassociateDRTRoleOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateDRTRoleRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DisassociateDRTRoleOutput) - return ret0, ret1 -} - -// DisassociateDRTRoleRequest indicates an expected call of DisassociateDRTRoleRequest. -func (mr *MockShieldMockRecorder) DisassociateDRTRoleRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateDRTRoleRequest", reflect.TypeOf((*MockShield)(nil).DisassociateDRTRoleRequest), arg0) -} - -// DisassociateDRTRoleWithContext mocks base method. -func (m *MockShield) DisassociateDRTRoleWithContext(arg0 context.Context, arg1 *shield.DisassociateDRTRoleInput, arg2 ...request.Option) (*shield.DisassociateDRTRoleOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateDRTRoleWithContext", varargs...) - ret0, _ := ret[0].(*shield.DisassociateDRTRoleOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateDRTRoleWithContext indicates an expected call of DisassociateDRTRoleWithContext. -func (mr *MockShieldMockRecorder) DisassociateDRTRoleWithContext(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, "DisassociateDRTRoleWithContext", reflect.TypeOf((*MockShield)(nil).DisassociateDRTRoleWithContext), varargs...) -} - -// DisassociateHealthCheck mocks base method. -func (m *MockShield) DisassociateHealthCheck(arg0 *shield.DisassociateHealthCheckInput) (*shield.DisassociateHealthCheckOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateHealthCheck", arg0) - ret0, _ := ret[0].(*shield.DisassociateHealthCheckOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateHealthCheck indicates an expected call of DisassociateHealthCheck. -func (mr *MockShieldMockRecorder) DisassociateHealthCheck(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateHealthCheck", reflect.TypeOf((*MockShield)(nil).DisassociateHealthCheck), arg0) -} - -// DisassociateHealthCheckRequest mocks base method. -func (m *MockShield) DisassociateHealthCheckRequest(arg0 *shield.DisassociateHealthCheckInput) (*request.Request, *shield.DisassociateHealthCheckOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "DisassociateHealthCheckRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.DisassociateHealthCheckOutput) - return ret0, ret1 -} - -// DisassociateHealthCheckRequest indicates an expected call of DisassociateHealthCheckRequest. -func (mr *MockShieldMockRecorder) DisassociateHealthCheckRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateHealthCheckRequest", reflect.TypeOf((*MockShield)(nil).DisassociateHealthCheckRequest), arg0) -} - -// DisassociateHealthCheckWithContext mocks base method. -func (m *MockShield) DisassociateHealthCheckWithContext(arg0 context.Context, arg1 *shield.DisassociateHealthCheckInput, arg2 ...request.Option) (*shield.DisassociateHealthCheckOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "DisassociateHealthCheckWithContext", varargs...) - ret0, _ := ret[0].(*shield.DisassociateHealthCheckOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// DisassociateHealthCheckWithContext indicates an expected call of DisassociateHealthCheckWithContext. -func (mr *MockShieldMockRecorder) DisassociateHealthCheckWithContext(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, "DisassociateHealthCheckWithContext", reflect.TypeOf((*MockShield)(nil).DisassociateHealthCheckWithContext), varargs...) -} - -// EnableApplicationLayerAutomaticResponse mocks base method. -func (m *MockShield) EnableApplicationLayerAutomaticResponse(arg0 *shield.EnableApplicationLayerAutomaticResponseInput) (*shield.EnableApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableApplicationLayerAutomaticResponse", arg0) - ret0, _ := ret[0].(*shield.EnableApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableApplicationLayerAutomaticResponse indicates an expected call of EnableApplicationLayerAutomaticResponse. -func (mr *MockShieldMockRecorder) EnableApplicationLayerAutomaticResponse(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableApplicationLayerAutomaticResponse", reflect.TypeOf((*MockShield)(nil).EnableApplicationLayerAutomaticResponse), arg0) -} - -// EnableApplicationLayerAutomaticResponseRequest mocks base method. -func (m *MockShield) EnableApplicationLayerAutomaticResponseRequest(arg0 *shield.EnableApplicationLayerAutomaticResponseInput) (*request.Request, *shield.EnableApplicationLayerAutomaticResponseOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableApplicationLayerAutomaticResponseRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.EnableApplicationLayerAutomaticResponseOutput) - return ret0, ret1 -} - -// EnableApplicationLayerAutomaticResponseRequest indicates an expected call of EnableApplicationLayerAutomaticResponseRequest. -func (mr *MockShieldMockRecorder) EnableApplicationLayerAutomaticResponseRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableApplicationLayerAutomaticResponseRequest", reflect.TypeOf((*MockShield)(nil).EnableApplicationLayerAutomaticResponseRequest), arg0) -} - -// EnableApplicationLayerAutomaticResponseWithContext mocks base method. -func (m *MockShield) EnableApplicationLayerAutomaticResponseWithContext(arg0 context.Context, arg1 *shield.EnableApplicationLayerAutomaticResponseInput, arg2 ...request.Option) (*shield.EnableApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableApplicationLayerAutomaticResponseWithContext", varargs...) - ret0, _ := ret[0].(*shield.EnableApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableApplicationLayerAutomaticResponseWithContext indicates an expected call of EnableApplicationLayerAutomaticResponseWithContext. -func (mr *MockShieldMockRecorder) EnableApplicationLayerAutomaticResponseWithContext(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, "EnableApplicationLayerAutomaticResponseWithContext", reflect.TypeOf((*MockShield)(nil).EnableApplicationLayerAutomaticResponseWithContext), varargs...) -} - -// EnableProactiveEngagement mocks base method. -func (m *MockShield) EnableProactiveEngagement(arg0 *shield.EnableProactiveEngagementInput) (*shield.EnableProactiveEngagementOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableProactiveEngagement", arg0) - ret0, _ := ret[0].(*shield.EnableProactiveEngagementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableProactiveEngagement indicates an expected call of EnableProactiveEngagement. -func (mr *MockShieldMockRecorder) EnableProactiveEngagement(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableProactiveEngagement", reflect.TypeOf((*MockShield)(nil).EnableProactiveEngagement), arg0) -} - -// EnableProactiveEngagementRequest mocks base method. -func (m *MockShield) EnableProactiveEngagementRequest(arg0 *shield.EnableProactiveEngagementInput) (*request.Request, *shield.EnableProactiveEngagementOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "EnableProactiveEngagementRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.EnableProactiveEngagementOutput) - return ret0, ret1 -} - -// EnableProactiveEngagementRequest indicates an expected call of EnableProactiveEngagementRequest. -func (mr *MockShieldMockRecorder) EnableProactiveEngagementRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableProactiveEngagementRequest", reflect.TypeOf((*MockShield)(nil).EnableProactiveEngagementRequest), arg0) -} - -// EnableProactiveEngagementWithContext mocks base method. -func (m *MockShield) EnableProactiveEngagementWithContext(arg0 context.Context, arg1 *shield.EnableProactiveEngagementInput, arg2 ...request.Option) (*shield.EnableProactiveEngagementOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "EnableProactiveEngagementWithContext", varargs...) - ret0, _ := ret[0].(*shield.EnableProactiveEngagementOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// EnableProactiveEngagementWithContext indicates an expected call of EnableProactiveEngagementWithContext. -func (mr *MockShieldMockRecorder) EnableProactiveEngagementWithContext(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, "EnableProactiveEngagementWithContext", reflect.TypeOf((*MockShield)(nil).EnableProactiveEngagementWithContext), varargs...) -} - -// GetSubscriptionState mocks base method. -func (m *MockShield) GetSubscriptionState(arg0 *shield.GetSubscriptionStateInput) (*shield.GetSubscriptionStateOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSubscriptionState", arg0) - ret0, _ := ret[0].(*shield.GetSubscriptionStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSubscriptionState indicates an expected call of GetSubscriptionState. -func (mr *MockShieldMockRecorder) GetSubscriptionState(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionState", reflect.TypeOf((*MockShield)(nil).GetSubscriptionState), arg0) -} - -// GetSubscriptionStateRequest mocks base method. -func (m *MockShield) GetSubscriptionStateRequest(arg0 *shield.GetSubscriptionStateInput) (*request.Request, *shield.GetSubscriptionStateOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetSubscriptionStateRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.GetSubscriptionStateOutput) - return ret0, ret1 -} - -// GetSubscriptionStateRequest indicates an expected call of GetSubscriptionStateRequest. -func (mr *MockShieldMockRecorder) GetSubscriptionStateRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionStateRequest", reflect.TypeOf((*MockShield)(nil).GetSubscriptionStateRequest), arg0) -} - -// GetSubscriptionStateWithContext mocks base method. -func (m *MockShield) GetSubscriptionStateWithContext(arg0 context.Context, arg1 *shield.GetSubscriptionStateInput, arg2 ...request.Option) (*shield.GetSubscriptionStateOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "GetSubscriptionStateWithContext", varargs...) - ret0, _ := ret[0].(*shield.GetSubscriptionStateOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// GetSubscriptionStateWithContext indicates an expected call of GetSubscriptionStateWithContext. -func (mr *MockShieldMockRecorder) GetSubscriptionStateWithContext(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, "GetSubscriptionStateWithContext", reflect.TypeOf((*MockShield)(nil).GetSubscriptionStateWithContext), varargs...) -} - -// ListAttacks mocks base method. -func (m *MockShield) ListAttacks(arg0 *shield.ListAttacksInput) (*shield.ListAttacksOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAttacks", arg0) - ret0, _ := ret[0].(*shield.ListAttacksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAttacks indicates an expected call of ListAttacks. -func (mr *MockShieldMockRecorder) ListAttacks(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttacks", reflect.TypeOf((*MockShield)(nil).ListAttacks), arg0) -} - -// ListAttacksPages mocks base method. -func (m *MockShield) ListAttacksPages(arg0 *shield.ListAttacksInput, arg1 func(*shield.ListAttacksOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAttacksPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAttacksPages indicates an expected call of ListAttacksPages. -func (mr *MockShieldMockRecorder) ListAttacksPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttacksPages", reflect.TypeOf((*MockShield)(nil).ListAttacksPages), arg0, arg1) -} - -// ListAttacksPagesWithContext mocks base method. -func (m *MockShield) ListAttacksPagesWithContext(arg0 context.Context, arg1 *shield.ListAttacksInput, arg2 func(*shield.ListAttacksOutput, 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, "ListAttacksPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListAttacksPagesWithContext indicates an expected call of ListAttacksPagesWithContext. -func (mr *MockShieldMockRecorder) ListAttacksPagesWithContext(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, "ListAttacksPagesWithContext", reflect.TypeOf((*MockShield)(nil).ListAttacksPagesWithContext), varargs...) -} - -// ListAttacksRequest mocks base method. -func (m *MockShield) ListAttacksRequest(arg0 *shield.ListAttacksInput) (*request.Request, *shield.ListAttacksOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListAttacksRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.ListAttacksOutput) - return ret0, ret1 -} - -// ListAttacksRequest indicates an expected call of ListAttacksRequest. -func (mr *MockShieldMockRecorder) ListAttacksRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAttacksRequest", reflect.TypeOf((*MockShield)(nil).ListAttacksRequest), arg0) -} - -// ListAttacksWithContext mocks base method. -func (m *MockShield) ListAttacksWithContext(arg0 context.Context, arg1 *shield.ListAttacksInput, arg2 ...request.Option) (*shield.ListAttacksOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListAttacksWithContext", varargs...) - ret0, _ := ret[0].(*shield.ListAttacksOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListAttacksWithContext indicates an expected call of ListAttacksWithContext. -func (mr *MockShieldMockRecorder) ListAttacksWithContext(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, "ListAttacksWithContext", reflect.TypeOf((*MockShield)(nil).ListAttacksWithContext), varargs...) -} - -// ListProtectionGroups mocks base method. -func (m *MockShield) ListProtectionGroups(arg0 *shield.ListProtectionGroupsInput) (*shield.ListProtectionGroupsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtectionGroups", arg0) - ret0, _ := ret[0].(*shield.ListProtectionGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListProtectionGroups indicates an expected call of ListProtectionGroups. -func (mr *MockShieldMockRecorder) ListProtectionGroups(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtectionGroups", reflect.TypeOf((*MockShield)(nil).ListProtectionGroups), arg0) -} - -// ListProtectionGroupsPages mocks base method. -func (m *MockShield) ListProtectionGroupsPages(arg0 *shield.ListProtectionGroupsInput, arg1 func(*shield.ListProtectionGroupsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtectionGroupsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListProtectionGroupsPages indicates an expected call of ListProtectionGroupsPages. -func (mr *MockShieldMockRecorder) ListProtectionGroupsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtectionGroupsPages", reflect.TypeOf((*MockShield)(nil).ListProtectionGroupsPages), arg0, arg1) -} - -// ListProtectionGroupsPagesWithContext mocks base method. -func (m *MockShield) ListProtectionGroupsPagesWithContext(arg0 context.Context, arg1 *shield.ListProtectionGroupsInput, arg2 func(*shield.ListProtectionGroupsOutput, 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, "ListProtectionGroupsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListProtectionGroupsPagesWithContext indicates an expected call of ListProtectionGroupsPagesWithContext. -func (mr *MockShieldMockRecorder) ListProtectionGroupsPagesWithContext(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, "ListProtectionGroupsPagesWithContext", reflect.TypeOf((*MockShield)(nil).ListProtectionGroupsPagesWithContext), varargs...) -} - -// ListProtectionGroupsRequest mocks base method. -func (m *MockShield) ListProtectionGroupsRequest(arg0 *shield.ListProtectionGroupsInput) (*request.Request, *shield.ListProtectionGroupsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtectionGroupsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.ListProtectionGroupsOutput) - return ret0, ret1 -} - -// ListProtectionGroupsRequest indicates an expected call of ListProtectionGroupsRequest. -func (mr *MockShieldMockRecorder) ListProtectionGroupsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtectionGroupsRequest", reflect.TypeOf((*MockShield)(nil).ListProtectionGroupsRequest), arg0) -} - -// ListProtectionGroupsWithContext mocks base method. -func (m *MockShield) ListProtectionGroupsWithContext(arg0 context.Context, arg1 *shield.ListProtectionGroupsInput, arg2 ...request.Option) (*shield.ListProtectionGroupsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListProtectionGroupsWithContext", varargs...) - ret0, _ := ret[0].(*shield.ListProtectionGroupsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListProtectionGroupsWithContext indicates an expected call of ListProtectionGroupsWithContext. -func (mr *MockShieldMockRecorder) ListProtectionGroupsWithContext(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, "ListProtectionGroupsWithContext", reflect.TypeOf((*MockShield)(nil).ListProtectionGroupsWithContext), varargs...) -} - -// ListProtections mocks base method. -func (m *MockShield) ListProtections(arg0 *shield.ListProtectionsInput) (*shield.ListProtectionsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtections", arg0) - ret0, _ := ret[0].(*shield.ListProtectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListProtections indicates an expected call of ListProtections. -func (mr *MockShieldMockRecorder) ListProtections(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtections", reflect.TypeOf((*MockShield)(nil).ListProtections), arg0) -} - -// ListProtectionsPages mocks base method. -func (m *MockShield) ListProtectionsPages(arg0 *shield.ListProtectionsInput, arg1 func(*shield.ListProtectionsOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtectionsPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListProtectionsPages indicates an expected call of ListProtectionsPages. -func (mr *MockShieldMockRecorder) ListProtectionsPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtectionsPages", reflect.TypeOf((*MockShield)(nil).ListProtectionsPages), arg0, arg1) -} - -// ListProtectionsPagesWithContext mocks base method. -func (m *MockShield) ListProtectionsPagesWithContext(arg0 context.Context, arg1 *shield.ListProtectionsInput, arg2 func(*shield.ListProtectionsOutput, 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, "ListProtectionsPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListProtectionsPagesWithContext indicates an expected call of ListProtectionsPagesWithContext. -func (mr *MockShieldMockRecorder) ListProtectionsPagesWithContext(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, "ListProtectionsPagesWithContext", reflect.TypeOf((*MockShield)(nil).ListProtectionsPagesWithContext), varargs...) -} - -// ListProtectionsRequest mocks base method. -func (m *MockShield) ListProtectionsRequest(arg0 *shield.ListProtectionsInput) (*request.Request, *shield.ListProtectionsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListProtectionsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.ListProtectionsOutput) - return ret0, ret1 -} - -// ListProtectionsRequest indicates an expected call of ListProtectionsRequest. -func (mr *MockShieldMockRecorder) ListProtectionsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProtectionsRequest", reflect.TypeOf((*MockShield)(nil).ListProtectionsRequest), arg0) -} - -// ListProtectionsWithContext mocks base method. -func (m *MockShield) ListProtectionsWithContext(arg0 context.Context, arg1 *shield.ListProtectionsInput, arg2 ...request.Option) (*shield.ListProtectionsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListProtectionsWithContext", varargs...) - ret0, _ := ret[0].(*shield.ListProtectionsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListProtectionsWithContext indicates an expected call of ListProtectionsWithContext. -func (mr *MockShieldMockRecorder) ListProtectionsWithContext(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, "ListProtectionsWithContext", reflect.TypeOf((*MockShield)(nil).ListProtectionsWithContext), varargs...) -} - -// ListResourcesInProtectionGroup mocks base method. -func (m *MockShield) ListResourcesInProtectionGroup(arg0 *shield.ListResourcesInProtectionGroupInput) (*shield.ListResourcesInProtectionGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourcesInProtectionGroup", arg0) - ret0, _ := ret[0].(*shield.ListResourcesInProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourcesInProtectionGroup indicates an expected call of ListResourcesInProtectionGroup. -func (mr *MockShieldMockRecorder) ListResourcesInProtectionGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourcesInProtectionGroup", reflect.TypeOf((*MockShield)(nil).ListResourcesInProtectionGroup), arg0) -} - -// ListResourcesInProtectionGroupPages mocks base method. -func (m *MockShield) ListResourcesInProtectionGroupPages(arg0 *shield.ListResourcesInProtectionGroupInput, arg1 func(*shield.ListResourcesInProtectionGroupOutput, bool) bool) error { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourcesInProtectionGroupPages", arg0, arg1) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourcesInProtectionGroupPages indicates an expected call of ListResourcesInProtectionGroupPages. -func (mr *MockShieldMockRecorder) ListResourcesInProtectionGroupPages(arg0, arg1 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourcesInProtectionGroupPages", reflect.TypeOf((*MockShield)(nil).ListResourcesInProtectionGroupPages), arg0, arg1) -} - -// ListResourcesInProtectionGroupPagesWithContext mocks base method. -func (m *MockShield) ListResourcesInProtectionGroupPagesWithContext(arg0 context.Context, arg1 *shield.ListResourcesInProtectionGroupInput, arg2 func(*shield.ListResourcesInProtectionGroupOutput, 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, "ListResourcesInProtectionGroupPagesWithContext", varargs...) - ret0, _ := ret[0].(error) - return ret0 -} - -// ListResourcesInProtectionGroupPagesWithContext indicates an expected call of ListResourcesInProtectionGroupPagesWithContext. -func (mr *MockShieldMockRecorder) ListResourcesInProtectionGroupPagesWithContext(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, "ListResourcesInProtectionGroupPagesWithContext", reflect.TypeOf((*MockShield)(nil).ListResourcesInProtectionGroupPagesWithContext), varargs...) -} - -// ListResourcesInProtectionGroupRequest mocks base method. -func (m *MockShield) ListResourcesInProtectionGroupRequest(arg0 *shield.ListResourcesInProtectionGroupInput) (*request.Request, *shield.ListResourcesInProtectionGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListResourcesInProtectionGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.ListResourcesInProtectionGroupOutput) - return ret0, ret1 -} - -// ListResourcesInProtectionGroupRequest indicates an expected call of ListResourcesInProtectionGroupRequest. -func (mr *MockShieldMockRecorder) ListResourcesInProtectionGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourcesInProtectionGroupRequest", reflect.TypeOf((*MockShield)(nil).ListResourcesInProtectionGroupRequest), arg0) -} - -// ListResourcesInProtectionGroupWithContext mocks base method. -func (m *MockShield) ListResourcesInProtectionGroupWithContext(arg0 context.Context, arg1 *shield.ListResourcesInProtectionGroupInput, arg2 ...request.Option) (*shield.ListResourcesInProtectionGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListResourcesInProtectionGroupWithContext", varargs...) - ret0, _ := ret[0].(*shield.ListResourcesInProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListResourcesInProtectionGroupWithContext indicates an expected call of ListResourcesInProtectionGroupWithContext. -func (mr *MockShieldMockRecorder) ListResourcesInProtectionGroupWithContext(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, "ListResourcesInProtectionGroupWithContext", reflect.TypeOf((*MockShield)(nil).ListResourcesInProtectionGroupWithContext), varargs...) -} - -// ListTagsForResource mocks base method. -func (m *MockShield) ListTagsForResource(arg0 *shield.ListTagsForResourceInput) (*shield.ListTagsForResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTagsForResource", arg0) - ret0, _ := ret[0].(*shield.ListTagsForResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListTagsForResource indicates an expected call of ListTagsForResource. -func (mr *MockShieldMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockShield)(nil).ListTagsForResource), arg0) -} - -// ListTagsForResourceRequest mocks base method. -func (m *MockShield) ListTagsForResourceRequest(arg0 *shield.ListTagsForResourceInput) (*request.Request, *shield.ListTagsForResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.ListTagsForResourceOutput) - return ret0, ret1 -} - -// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest. -func (mr *MockShieldMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockShield)(nil).ListTagsForResourceRequest), arg0) -} - -// ListTagsForResourceWithContext mocks base method. -func (m *MockShield) ListTagsForResourceWithContext(arg0 context.Context, arg1 *shield.ListTagsForResourceInput, arg2 ...request.Option) (*shield.ListTagsForResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...) - ret0, _ := ret[0].(*shield.ListTagsForResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext. -func (mr *MockShieldMockRecorder) ListTagsForResourceWithContext(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, "ListTagsForResourceWithContext", reflect.TypeOf((*MockShield)(nil).ListTagsForResourceWithContext), varargs...) -} - -// TagResource mocks base method. -func (m *MockShield) TagResource(arg0 *shield.TagResourceInput) (*shield.TagResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TagResource", arg0) - ret0, _ := ret[0].(*shield.TagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TagResource indicates an expected call of TagResource. -func (mr *MockShieldMockRecorder) TagResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockShield)(nil).TagResource), arg0) -} - -// TagResourceRequest mocks base method. -func (m *MockShield) TagResourceRequest(arg0 *shield.TagResourceInput) (*request.Request, *shield.TagResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "TagResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.TagResourceOutput) - return ret0, ret1 -} - -// TagResourceRequest indicates an expected call of TagResourceRequest. -func (mr *MockShieldMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockShield)(nil).TagResourceRequest), arg0) -} - -// TagResourceWithContext mocks base method. -func (m *MockShield) TagResourceWithContext(arg0 context.Context, arg1 *shield.TagResourceInput, arg2 ...request.Option) (*shield.TagResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...) - ret0, _ := ret[0].(*shield.TagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// TagResourceWithContext indicates an expected call of TagResourceWithContext. -func (mr *MockShieldMockRecorder) TagResourceWithContext(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, "TagResourceWithContext", reflect.TypeOf((*MockShield)(nil).TagResourceWithContext), varargs...) -} - -// UntagResource mocks base method. -func (m *MockShield) UntagResource(arg0 *shield.UntagResourceInput) (*shield.UntagResourceOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UntagResource", arg0) - ret0, _ := ret[0].(*shield.UntagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UntagResource indicates an expected call of UntagResource. -func (mr *MockShieldMockRecorder) UntagResource(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockShield)(nil).UntagResource), arg0) -} - -// UntagResourceRequest mocks base method. -func (m *MockShield) UntagResourceRequest(arg0 *shield.UntagResourceInput) (*request.Request, *shield.UntagResourceOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UntagResourceRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.UntagResourceOutput) - return ret0, ret1 -} - -// UntagResourceRequest indicates an expected call of UntagResourceRequest. -func (mr *MockShieldMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockShield)(nil).UntagResourceRequest), arg0) -} - -// UntagResourceWithContext mocks base method. -func (m *MockShield) UntagResourceWithContext(arg0 context.Context, arg1 *shield.UntagResourceInput, arg2 ...request.Option) (*shield.UntagResourceOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...) - ret0, _ := ret[0].(*shield.UntagResourceOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UntagResourceWithContext indicates an expected call of UntagResourceWithContext. -func (mr *MockShieldMockRecorder) UntagResourceWithContext(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, "UntagResourceWithContext", reflect.TypeOf((*MockShield)(nil).UntagResourceWithContext), varargs...) -} - -// UpdateApplicationLayerAutomaticResponse mocks base method. -func (m *MockShield) UpdateApplicationLayerAutomaticResponse(arg0 *shield.UpdateApplicationLayerAutomaticResponseInput) (*shield.UpdateApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateApplicationLayerAutomaticResponse", arg0) - ret0, _ := ret[0].(*shield.UpdateApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateApplicationLayerAutomaticResponse indicates an expected call of UpdateApplicationLayerAutomaticResponse. -func (mr *MockShieldMockRecorder) UpdateApplicationLayerAutomaticResponse(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplicationLayerAutomaticResponse", reflect.TypeOf((*MockShield)(nil).UpdateApplicationLayerAutomaticResponse), arg0) -} - -// UpdateApplicationLayerAutomaticResponseRequest mocks base method. -func (m *MockShield) UpdateApplicationLayerAutomaticResponseRequest(arg0 *shield.UpdateApplicationLayerAutomaticResponseInput) (*request.Request, *shield.UpdateApplicationLayerAutomaticResponseOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateApplicationLayerAutomaticResponseRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.UpdateApplicationLayerAutomaticResponseOutput) - return ret0, ret1 -} - -// UpdateApplicationLayerAutomaticResponseRequest indicates an expected call of UpdateApplicationLayerAutomaticResponseRequest. -func (mr *MockShieldMockRecorder) UpdateApplicationLayerAutomaticResponseRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateApplicationLayerAutomaticResponseRequest", reflect.TypeOf((*MockShield)(nil).UpdateApplicationLayerAutomaticResponseRequest), arg0) -} - -// UpdateApplicationLayerAutomaticResponseWithContext mocks base method. -func (m *MockShield) UpdateApplicationLayerAutomaticResponseWithContext(arg0 context.Context, arg1 *shield.UpdateApplicationLayerAutomaticResponseInput, arg2 ...request.Option) (*shield.UpdateApplicationLayerAutomaticResponseOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateApplicationLayerAutomaticResponseWithContext", varargs...) - ret0, _ := ret[0].(*shield.UpdateApplicationLayerAutomaticResponseOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateApplicationLayerAutomaticResponseWithContext indicates an expected call of UpdateApplicationLayerAutomaticResponseWithContext. -func (mr *MockShieldMockRecorder) UpdateApplicationLayerAutomaticResponseWithContext(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, "UpdateApplicationLayerAutomaticResponseWithContext", reflect.TypeOf((*MockShield)(nil).UpdateApplicationLayerAutomaticResponseWithContext), varargs...) -} - -// UpdateEmergencyContactSettings mocks base method. -func (m *MockShield) UpdateEmergencyContactSettings(arg0 *shield.UpdateEmergencyContactSettingsInput) (*shield.UpdateEmergencyContactSettingsOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateEmergencyContactSettings", arg0) - ret0, _ := ret[0].(*shield.UpdateEmergencyContactSettingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateEmergencyContactSettings indicates an expected call of UpdateEmergencyContactSettings. -func (mr *MockShieldMockRecorder) UpdateEmergencyContactSettings(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEmergencyContactSettings", reflect.TypeOf((*MockShield)(nil).UpdateEmergencyContactSettings), arg0) -} - -// UpdateEmergencyContactSettingsRequest mocks base method. -func (m *MockShield) UpdateEmergencyContactSettingsRequest(arg0 *shield.UpdateEmergencyContactSettingsInput) (*request.Request, *shield.UpdateEmergencyContactSettingsOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateEmergencyContactSettingsRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.UpdateEmergencyContactSettingsOutput) - return ret0, ret1 -} - -// UpdateEmergencyContactSettingsRequest indicates an expected call of UpdateEmergencyContactSettingsRequest. -func (mr *MockShieldMockRecorder) UpdateEmergencyContactSettingsRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateEmergencyContactSettingsRequest", reflect.TypeOf((*MockShield)(nil).UpdateEmergencyContactSettingsRequest), arg0) -} - -// UpdateEmergencyContactSettingsWithContext mocks base method. -func (m *MockShield) UpdateEmergencyContactSettingsWithContext(arg0 context.Context, arg1 *shield.UpdateEmergencyContactSettingsInput, arg2 ...request.Option) (*shield.UpdateEmergencyContactSettingsOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateEmergencyContactSettingsWithContext", varargs...) - ret0, _ := ret[0].(*shield.UpdateEmergencyContactSettingsOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateEmergencyContactSettingsWithContext indicates an expected call of UpdateEmergencyContactSettingsWithContext. -func (mr *MockShieldMockRecorder) UpdateEmergencyContactSettingsWithContext(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, "UpdateEmergencyContactSettingsWithContext", reflect.TypeOf((*MockShield)(nil).UpdateEmergencyContactSettingsWithContext), varargs...) -} - -// UpdateProtectionGroup mocks base method. -func (m *MockShield) UpdateProtectionGroup(arg0 *shield.UpdateProtectionGroupInput) (*shield.UpdateProtectionGroupOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateProtectionGroup", arg0) - ret0, _ := ret[0].(*shield.UpdateProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateProtectionGroup indicates an expected call of UpdateProtectionGroup. -func (mr *MockShieldMockRecorder) UpdateProtectionGroup(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectionGroup", reflect.TypeOf((*MockShield)(nil).UpdateProtectionGroup), arg0) -} - -// UpdateProtectionGroupRequest mocks base method. -func (m *MockShield) UpdateProtectionGroupRequest(arg0 *shield.UpdateProtectionGroupInput) (*request.Request, *shield.UpdateProtectionGroupOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateProtectionGroupRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.UpdateProtectionGroupOutput) - return ret0, ret1 -} - -// UpdateProtectionGroupRequest indicates an expected call of UpdateProtectionGroupRequest. -func (mr *MockShieldMockRecorder) UpdateProtectionGroupRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProtectionGroupRequest", reflect.TypeOf((*MockShield)(nil).UpdateProtectionGroupRequest), arg0) -} - -// UpdateProtectionGroupWithContext mocks base method. -func (m *MockShield) UpdateProtectionGroupWithContext(arg0 context.Context, arg1 *shield.UpdateProtectionGroupInput, arg2 ...request.Option) (*shield.UpdateProtectionGroupOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateProtectionGroupWithContext", varargs...) - ret0, _ := ret[0].(*shield.UpdateProtectionGroupOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateProtectionGroupWithContext indicates an expected call of UpdateProtectionGroupWithContext. -func (mr *MockShieldMockRecorder) UpdateProtectionGroupWithContext(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, "UpdateProtectionGroupWithContext", reflect.TypeOf((*MockShield)(nil).UpdateProtectionGroupWithContext), varargs...) -} - -// UpdateSubscription mocks base method. -func (m *MockShield) UpdateSubscription(arg0 *shield.UpdateSubscriptionInput) (*shield.UpdateSubscriptionOutput, error) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSubscription", arg0) - ret0, _ := ret[0].(*shield.UpdateSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSubscription indicates an expected call of UpdateSubscription. -func (mr *MockShieldMockRecorder) UpdateSubscription(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubscription", reflect.TypeOf((*MockShield)(nil).UpdateSubscription), arg0) -} - -// UpdateSubscriptionRequest mocks base method. -func (m *MockShield) UpdateSubscriptionRequest(arg0 *shield.UpdateSubscriptionInput) (*request.Request, *shield.UpdateSubscriptionOutput) { - m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateSubscriptionRequest", arg0) - ret0, _ := ret[0].(*request.Request) - ret1, _ := ret[1].(*shield.UpdateSubscriptionOutput) - return ret0, ret1 -} - -// UpdateSubscriptionRequest indicates an expected call of UpdateSubscriptionRequest. -func (mr *MockShieldMockRecorder) UpdateSubscriptionRequest(arg0 interface{}) *gomock.Call { - mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubscriptionRequest", reflect.TypeOf((*MockShield)(nil).UpdateSubscriptionRequest), arg0) -} - -// UpdateSubscriptionWithContext mocks base method. -func (m *MockShield) UpdateSubscriptionWithContext(arg0 context.Context, arg1 *shield.UpdateSubscriptionInput, arg2 ...request.Option) (*shield.UpdateSubscriptionOutput, error) { - m.ctrl.T.Helper() - varargs := []interface{}{arg0, arg1} - for _, a := range arg2 { - varargs = append(varargs, a) - } - ret := m.ctrl.Call(m, "UpdateSubscriptionWithContext", varargs...) - ret0, _ := ret[0].(*shield.UpdateSubscriptionOutput) - ret1, _ := ret[1].(error) - return ret0, ret1 -} - -// UpdateSubscriptionWithContext indicates an expected call of UpdateSubscriptionWithContext. -func (mr *MockShieldMockRecorder) UpdateSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { +// GetSubscriptionStateWithContext indicates an expected call of GetSubscriptionStateWithContext. +func (mr *MockShieldMockRecorder) GetSubscriptionStateWithContext(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() - varargs := append([]interface{}{arg0, arg1}, arg2...) - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSubscriptionWithContext", reflect.TypeOf((*MockShield)(nil).UpdateSubscriptionWithContext), varargs...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionStateWithContext", reflect.TypeOf((*MockShield)(nil).GetSubscriptionStateWithContext), arg0, arg1) } diff --git a/pkg/aws/services/wafregional.go b/pkg/aws/services/wafregional.go index b3acd0806c..6fd0ae2695 100644 --- a/pkg/aws/services/wafregional.go +++ b/pkg/aws/services/wafregional.go @@ -1,35 +1,51 @@ package services import ( - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/endpoints" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/wafregional" - "github.com/aws/aws-sdk-go/service/wafregional/wafregionaliface" + "context" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/wafregional" ) type WAFRegional interface { - wafregionaliface.WAFRegionalAPI - Available() bool + + AssociateWebACLWithContext(ctx context.Context, input *wafregional.AssociateWebACLInput) (*wafregional.AssociateWebACLOutput, error) + DisassociateWebACLWithContext(ctx context.Context, input *wafregional.DisassociateWebACLInput) (*wafregional.DisassociateWebACLOutput, error) + GetWebACLForResourceWithContext(ctx context.Context, input *wafregional.GetWebACLForResourceInput) (*wafregional.GetWebACLForResourceOutput, error) } // NewWAFRegional constructs new WAFRegional implementation. -func NewWAFRegional(session *session.Session, region string) WAFRegional { - return &defaultWAFRegional{ - WAFRegionalAPI: wafregional.New(session, aws.NewConfig().WithRegion(region)), - region: region, +func NewWAFRegional(cfg aws.Config, region string) WAFRegional { + return &wafRegionalClient{ + wafRegionalClient: wafregional.NewFromConfig(cfg, func(o *wafregional.Options) { + o.Region = region + }), + region: region, } } // default implementation for WAFRegional. -type defaultWAFRegional struct { - wafregionaliface.WAFRegionalAPI - region string +type wafRegionalClient struct { + wafRegionalClient *wafregional.Client + region string } -func (c *defaultWAFRegional) Available() bool { - resolver := endpoints.DefaultResolver() - _, err := resolver.EndpointFor(wafregional.EndpointsID, c.region, endpoints.StrictMatchingOption) +func (c *wafRegionalClient) Available() bool { + resolver := wafregional.NewDefaultEndpointResolverV2() + _, err := resolver.ResolveEndpoint(context.Background(), wafregional.EndpointParameters{ + Region: &c.region, + }) return err == nil } + +func (c *wafRegionalClient) AssociateWebACLWithContext(ctx context.Context, input *wafregional.AssociateWebACLInput) (*wafregional.AssociateWebACLOutput, error) { + return c.wafRegionalClient.AssociateWebACL(ctx, input) +} + +func (c *wafRegionalClient) DisassociateWebACLWithContext(ctx context.Context, input *wafregional.DisassociateWebACLInput) (*wafregional.DisassociateWebACLOutput, error) { + return c.wafRegionalClient.DisassociateWebACL(ctx, input) +} + +func (c *wafRegionalClient) GetWebACLForResourceWithContext(ctx context.Context, input *wafregional.GetWebACLForResourceInput) (*wafregional.GetWebACLForResourceOutput, error) { + return c.wafRegionalClient.GetWebACLForResource(ctx, input) +} diff --git a/pkg/aws/services/wafregional_mocks.go b/pkg/aws/services/wafregional_mocks.go new file mode 100644 index 0000000000..d19f735783 --- /dev/null +++ b/pkg/aws/services/wafregional_mocks.go @@ -0,0 +1,95 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services (interfaces: WAFRegional) + +// Package services is a generated GoMock package. +package services + +import ( + context "context" + reflect "reflect" + + wafregional "github.com/aws/aws-sdk-go-v2/service/wafregional" + gomock "github.com/golang/mock/gomock" +) + +// MockWAFRegional is a mock of WAFRegional interface. +type MockWAFRegional struct { + ctrl *gomock.Controller + recorder *MockWAFRegionalMockRecorder +} + +// MockWAFRegionalMockRecorder is the mock recorder for MockWAFRegional. +type MockWAFRegionalMockRecorder struct { + mock *MockWAFRegional +} + +// NewMockWAFRegional creates a new mock instance. +func NewMockWAFRegional(ctrl *gomock.Controller) *MockWAFRegional { + mock := &MockWAFRegional{ctrl: ctrl} + mock.recorder = &MockWAFRegionalMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockWAFRegional) EXPECT() *MockWAFRegionalMockRecorder { + return m.recorder +} + +// AssociateWebACLWithContext mocks base method. +func (m *MockWAFRegional) AssociateWebACLWithContext(arg0 context.Context, arg1 *wafregional.AssociateWebACLInput) (*wafregional.AssociateWebACLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateWebACLWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafregional.AssociateWebACLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateWebACLWithContext indicates an expected call of AssociateWebACLWithContext. +func (mr *MockWAFRegionalMockRecorder) AssociateWebACLWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateWebACLWithContext", reflect.TypeOf((*MockWAFRegional)(nil).AssociateWebACLWithContext), arg0, arg1) +} + +// Available mocks base method. +func (m *MockWAFRegional) Available() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Available") + ret0, _ := ret[0].(bool) + return ret0 +} + +// Available indicates an expected call of Available. +func (mr *MockWAFRegionalMockRecorder) Available() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Available", reflect.TypeOf((*MockWAFRegional)(nil).Available)) +} + +// DisassociateWebACLWithContext mocks base method. +func (m *MockWAFRegional) DisassociateWebACLWithContext(arg0 context.Context, arg1 *wafregional.DisassociateWebACLInput) (*wafregional.DisassociateWebACLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateWebACLWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafregional.DisassociateWebACLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateWebACLWithContext indicates an expected call of DisassociateWebACLWithContext. +func (mr *MockWAFRegionalMockRecorder) DisassociateWebACLWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateWebACLWithContext", reflect.TypeOf((*MockWAFRegional)(nil).DisassociateWebACLWithContext), arg0, arg1) +} + +// GetWebACLForResourceWithContext mocks base method. +func (m *MockWAFRegional) GetWebACLForResourceWithContext(arg0 context.Context, arg1 *wafregional.GetWebACLForResourceInput) (*wafregional.GetWebACLForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWebACLForResourceWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafregional.GetWebACLForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWebACLForResourceWithContext indicates an expected call of GetWebACLForResourceWithContext. +func (mr *MockWAFRegionalMockRecorder) GetWebACLForResourceWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebACLForResourceWithContext", reflect.TypeOf((*MockWAFRegional)(nil).GetWebACLForResourceWithContext), arg0, arg1) +} diff --git a/pkg/aws/services/wafv2.go b/pkg/aws/services/wafv2.go index fd541ddb06..6a9337cc8f 100644 --- a/pkg/aws/services/wafv2.go +++ b/pkg/aws/services/wafv2.go @@ -1,23 +1,35 @@ package services import ( - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/wafv2" - "github.com/aws/aws-sdk-go/service/wafv2/wafv2iface" + "context" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/wafv2" ) type WAFv2 interface { - wafv2iface.WAFV2API + AssociateWebACLWithContext(context.Context, *wafv2.AssociateWebACLInput) (*wafv2.AssociateWebACLOutput, error) + DisassociateWebACLWithContext(ctx context.Context, req *wafv2.DisassociateWebACLInput) (*wafv2.DisassociateWebACLOutput, error) + GetWebACLForResourceWithContext(ctx context.Context, req *wafv2.GetWebACLForResourceInput) (*wafv2.GetWebACLForResourceOutput, error) } // NewWAFv2 constructs new WAFv2 implementation. -func NewWAFv2(session *session.Session) WAFv2 { - return &defaultWAFv2{ - WAFV2API: wafv2.New(session), - } +func NewWAFv2(cfg aws.Config) WAFv2 { + client := wafv2.NewFromConfig(cfg) + return &wafv2Client{wafv2Client: client} } -// default implementation for WAFv2. -type defaultWAFv2 struct { - wafv2iface.WAFV2API +type wafv2Client struct { + wafv2Client *wafv2.Client +} + +func (c *wafv2Client) AssociateWebACLWithContext(ctx context.Context, req *wafv2.AssociateWebACLInput) (*wafv2.AssociateWebACLOutput, error) { + return c.wafv2Client.AssociateWebACL(ctx, req) +} + +func (c *wafv2Client) DisassociateWebACLWithContext(ctx context.Context, req *wafv2.DisassociateWebACLInput) (*wafv2.DisassociateWebACLOutput, error) { + return c.wafv2Client.DisassociateWebACL(ctx, req) +} + +func (c *wafv2Client) GetWebACLForResourceWithContext(ctx context.Context, req *wafv2.GetWebACLForResourceInput) (*wafv2.GetWebACLForResourceOutput, error) { + return c.wafv2Client.GetWebACLForResource(ctx, req) } diff --git a/pkg/aws/services/wafv2_mocks.go b/pkg/aws/services/wafv2_mocks.go new file mode 100644 index 0000000000..234c56a9bc --- /dev/null +++ b/pkg/aws/services/wafv2_mocks.go @@ -0,0 +1,81 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services (interfaces: WAFv2) + +// Package services is a generated GoMock package. +package services + +import ( + context "context" + reflect "reflect" + + wafv2 "github.com/aws/aws-sdk-go-v2/service/wafv2" + gomock "github.com/golang/mock/gomock" +) + +// MockWAFv2 is a mock of WAFv2 interface. +type MockWAFv2 struct { + ctrl *gomock.Controller + recorder *MockWAFv2MockRecorder +} + +// MockWAFv2MockRecorder is the mock recorder for MockWAFv2. +type MockWAFv2MockRecorder struct { + mock *MockWAFv2 +} + +// NewMockWAFv2 creates a new mock instance. +func NewMockWAFv2(ctrl *gomock.Controller) *MockWAFv2 { + mock := &MockWAFv2{ctrl: ctrl} + mock.recorder = &MockWAFv2MockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockWAFv2) EXPECT() *MockWAFv2MockRecorder { + return m.recorder +} + +// AssociateWebACLWithContext mocks base method. +func (m *MockWAFv2) AssociateWebACLWithContext(arg0 context.Context, arg1 *wafv2.AssociateWebACLInput) (*wafv2.AssociateWebACLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AssociateWebACLWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafv2.AssociateWebACLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AssociateWebACLWithContext indicates an expected call of AssociateWebACLWithContext. +func (mr *MockWAFv2MockRecorder) AssociateWebACLWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateWebACLWithContext", reflect.TypeOf((*MockWAFv2)(nil).AssociateWebACLWithContext), arg0, arg1) +} + +// DisassociateWebACLWithContext mocks base method. +func (m *MockWAFv2) DisassociateWebACLWithContext(arg0 context.Context, arg1 *wafv2.DisassociateWebACLInput) (*wafv2.DisassociateWebACLOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisassociateWebACLWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafv2.DisassociateWebACLOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisassociateWebACLWithContext indicates an expected call of DisassociateWebACLWithContext. +func (mr *MockWAFv2MockRecorder) DisassociateWebACLWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateWebACLWithContext", reflect.TypeOf((*MockWAFv2)(nil).DisassociateWebACLWithContext), arg0, arg1) +} + +// GetWebACLForResourceWithContext mocks base method. +func (m *MockWAFv2) GetWebACLForResourceWithContext(arg0 context.Context, arg1 *wafv2.GetWebACLForResourceInput) (*wafv2.GetWebACLForResourceOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetWebACLForResourceWithContext", arg0, arg1) + ret0, _ := ret[0].(*wafv2.GetWebACLForResourceOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetWebACLForResourceWithContext indicates an expected call of GetWebACLForResourceWithContext. +func (mr *MockWAFv2MockRecorder) GetWebACLForResourceWithContext(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWebACLForResourceWithContext", reflect.TypeOf((*MockWAFv2)(nil).GetWebACLForResourceWithContext), arg0, arg1) +} diff --git a/pkg/aws/throttle/condition.go b/pkg/aws/throttle/condition.go index cbdc4182eb..8c1507bc54 100644 --- a/pkg/aws/throttle/condition.go +++ b/pkg/aws/throttle/condition.go @@ -1,32 +1,35 @@ package throttle -import ( - "github.com/aws/aws-sdk-go/aws/request" - "regexp" -) - -type Condition func(r *request.Request) bool - -func matchService(serviceID string) Condition { - return func(r *request.Request) bool { - return r.ClientInfo.ServiceID == serviceID - } -} - -func matchServiceOperation(serviceID string, operation string) Condition { - return func(r *request.Request) bool { - if r.Operation == nil { - return false - } - return r.ClientInfo.ServiceID == serviceID && r.Operation.Name == operation - } -} - -func matchServiceOperationPattern(serviceID string, operationPtn *regexp.Regexp) Condition { - return func(r *request.Request) bool { - if r.Operation == nil { - return false - } - return r.ClientInfo.ServiceID == serviceID && operationPtn.Match([]byte(r.Operation.Name)) - } -} +// TODO : WIP +//import ( +// "github.com/aws/aws-sdk-go/aws/request" +// smithyhttp "github.com/aws/smithy-go/transport/http" +// awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware/" +// "regexp" +//) +// +//type Condition func(r *awshttp.) bool +// +//func matchService(serviceID string) Condition { +// return func(r *awshttp.) bool { +// return awsmiddleware.GetServiceID() == serviceID +// } +//} +// +//func matchServiceOperation(serviceID string, operation string) Condition { +// return func(r *smithyhttp.Request) bool { +// if r.Operation == nil { +// return false +// } +// return r.ClientInfo.ServiceID == serviceID && r.Operation.Name == operation +// } +//} +// +//func matchServiceOperationPattern(serviceID string, operationPtn *regexp.Regexp) Condition { +// return func(r *smithyhttp.Request) bool { +// if r.Operation == nil { +// return false +// } +// return r.ClientInfo.ServiceID == serviceID && operationPtn.Match([]byte(r.Operation.Name)) +// } +//} diff --git a/pkg/aws/throttle/condition_test.go b/pkg/aws/throttle/condition_test.go index e69ccd3052..5493a21599 100644 --- a/pkg/aws/throttle/condition_test.go +++ b/pkg/aws/throttle/condition_test.go @@ -1,207 +1,206 @@ package throttle -import ( - "github.com/aws/aws-sdk-go/aws/client/metadata" - "github.com/aws/aws-sdk-go/aws/request" - "github.com/stretchr/testify/assert" - "regexp" - "testing" -) - -func Test_matchService(t *testing.T) { - type args struct { - serviceID string - } - tests := []struct { - name string - args args - req *request.Request - want bool - }{ - { - name: "service matches", - args: args{ - serviceID: "App Mesh", - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - }, - want: true, - }, - { - name: "service mismatches", - args: args{ - serviceID: "App Mesh", - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "S3", - }, - }, - want: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - predict := matchService(tt.args.serviceID) - got := predict(tt.req) - assert.Equal(t, tt.want, got) - }) - } -} - -func Test_matchServiceOperation(t *testing.T) { - type args struct { - serviceID string - operation string - } - tests := []struct { - name string - args args - req *request.Request - want bool - }{ - { - name: "operation matches", - args: args{ - serviceID: "App Mesh", - operation: "CreateMesh", - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: true, - }, - { - name: "operation mismatches", - args: args{ - serviceID: "App Mesh", - operation: "CreateMesh", - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "DescribeMesh", - }, - }, - want: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - predict := matchServiceOperation(tt.args.serviceID, tt.args.operation) - got := predict(tt.req) - assert.Equal(t, tt.want, got) - }) - } -} - -func Test_matchServiceOperationPattern(t *testing.T) { - type args struct { - serviceID string - operationPtn *regexp.Regexp - } - tests := []struct { - name string - args args - req *request.Request - want bool - }{ - { - name: "operationPtn matches - case 1", - args: args{ - serviceID: "App Mesh", - operationPtn: regexp.MustCompile("Create"), - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: true, - }, - { - name: "operationPtn matches - case 2", - args: args{ - serviceID: "App Mesh", - operationPtn: regexp.MustCompile("Create.*"), - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: true, - }, - { - name: "operationPtn matches - case 3", - args: args{ - serviceID: "App Mesh", - operationPtn: regexp.MustCompile("^Create"), - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: true, - }, - { - name: "operationPtn matches - case 4", - args: args{ - serviceID: "App Mesh", - operationPtn: regexp.MustCompile("Mesh"), - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: true, - }, - { - name: "operationPtn mismatches", - args: args{ - serviceID: "App Mesh", - operationPtn: regexp.MustCompile("Describe"), - }, - req: &request.Request{ - ClientInfo: metadata.ClientInfo{ - ServiceID: "App Mesh", - }, - Operation: &request.Operation{ - Name: "CreateMesh", - }, - }, - want: false, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - predict := matchServiceOperationPattern(tt.args.serviceID, tt.args.operationPtn) - got := predict(tt.req) - assert.Equal(t, tt.want, got) - }) - } -} +// TODO : WIP +//import ( +// "github.com/stretchr/testify/assert" +// "regexp" +// "testing" +//) +// +//func Test_matchService(t *testing.T) { +// type args struct { +// serviceID string +// } +// tests := []struct { +// name string +// args args +// req *request.Request +// want bool +// }{ +// { +// name: "service matches", +// args: args{ +// serviceID: "App Mesh", +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// }, +// want: true, +// }, +// { +// name: "service mismatches", +// args: args{ +// serviceID: "App Mesh", +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "S3", +// }, +// }, +// want: false, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// predict := matchService(tt.args.serviceID) +// got := predict(tt.req) +// assert.Equal(t, tt.want, got) +// }) +// } +//} +// +//func Test_matchServiceOperation(t *testing.T) { +// type args struct { +// serviceID string +// operation string +// } +// tests := []struct { +// name string +// args args +// req *request.Request +// want bool +// }{ +// { +// name: "operation matches", +// args: args{ +// serviceID: "App Mesh", +// operation: "CreateMesh", +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: true, +// }, +// { +// name: "operation mismatches", +// args: args{ +// serviceID: "App Mesh", +// operation: "CreateMesh", +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "DescribeMesh", +// }, +// }, +// want: false, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// predict := matchServiceOperation(tt.args.serviceID, tt.args.operation) +// got := predict(tt.req) +// assert.Equal(t, tt.want, got) +// }) +// } +//} +// +//func Test_matchServiceOperationPattern(t *testing.T) { +// type args struct { +// serviceID string +// operationPtn *regexp.Regexp +// } +// tests := []struct { +// name string +// args args +// req *request.Request +// want bool +// }{ +// { +// name: "operationPtn matches - case 1", +// args: args{ +// serviceID: "App Mesh", +// operationPtn: regexp.MustCompile("Create"), +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: true, +// }, +// { +// name: "operationPtn matches - case 2", +// args: args{ +// serviceID: "App Mesh", +// operationPtn: regexp.MustCompile("Create.*"), +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: true, +// }, +// { +// name: "operationPtn matches - case 3", +// args: args{ +// serviceID: "App Mesh", +// operationPtn: regexp.MustCompile("^Create"), +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: true, +// }, +// { +// name: "operationPtn matches - case 4", +// args: args{ +// serviceID: "App Mesh", +// operationPtn: regexp.MustCompile("Mesh"), +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: true, +// }, +// { +// name: "operationPtn mismatches", +// args: args{ +// serviceID: "App Mesh", +// operationPtn: regexp.MustCompile("Describe"), +// }, +// req: &request.Request{ +// ClientInfo: metadata.ClientInfo{ +// ServiceID: "App Mesh", +// }, +// Operation: &request.Operation{ +// Name: "CreateMesh", +// }, +// }, +// want: false, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// predict := matchServiceOperationPattern(tt.args.serviceID, tt.args.operationPtn) +// got := predict(tt.req) +// assert.Equal(t, tt.want, got) +// }) +// } +//} diff --git a/pkg/aws/throttle/config_test.go b/pkg/aws/throttle/config_test.go index 0b4798a4e7..fda3d7e372 100644 --- a/pkg/aws/throttle/config_test.go +++ b/pkg/aws/throttle/config_test.go @@ -1,259 +1,258 @@ package throttle -import ( - "github.com/aws/aws-sdk-go/service/appmesh" - "github.com/aws/aws-sdk-go/service/elbv2" - "github.com/aws/aws-sdk-go/service/servicediscovery" - "github.com/pkg/errors" - "github.com/stretchr/testify/assert" - "regexp" - "testing" -) - -func TestServiceOperationsThrottleConfig_String(t *testing.T) { - type fields struct { - value map[string][]throttleConfig - } - tests := []struct { - name string - fields fields - want string - }{ - { - name: "non-empty value", - fields: fields{ - value: map[string][]throttleConfig{ - appmesh.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 5, - }, - { - operationPtn: regexp.MustCompile("CreateMesh"), - r: 4.2, - burst: 5, - }, - }, - servicediscovery.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 5, - }, - }, - }, - }, - want: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:5,ServiceDiscovery:^Describe=4.2:5", - }, - { - name: "nil value", - fields: fields{ - value: nil, - }, - want: "", - }, - { - name: "empty value", - fields: fields{ - value: nil, - }, - want: "", - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - c := &ServiceOperationsThrottleConfig{ - value: tt.fields.value, - } - got := c.String() - assert.Equal(t, tt.want, got) - }) - } -} - -func TestServiceOperationsThrottleConfig_Set(t *testing.T) { - type fields struct { - value map[string][]throttleConfig - } - type args struct { - val string - } - tests := []struct { - name string - fields fields - args args - want ServiceOperationsThrottleConfig - wantErr error - }{ - { - name: "when default value is nil", - fields: fields{ - value: nil, - }, - args: args{ - val: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:6,ServiceDiscovery:^Describe=4.2:7", - }, - want: ServiceOperationsThrottleConfig{ - value: map[string][]throttleConfig{ - appmesh.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 5, - }, - { - operationPtn: regexp.MustCompile("CreateMesh"), - r: 4.2, - burst: 6, - }, - }, - servicediscovery.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 7, - }, - }, - }, - }, - }, - { - name: "when default value contains non-empty defaults", - fields: fields{ - value: map[string][]throttleConfig{ - elbv2.ServiceID: { - { - operationPtn: regexp.MustCompile("^Create"), - r: 4.2, - burst: 4, - }, - }, - }, - }, - args: args{ - val: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:6,ServiceDiscovery:^Describe=4.2:7", - }, - want: ServiceOperationsThrottleConfig{ - value: map[string][]throttleConfig{ - elbv2.ServiceID: { - { - operationPtn: regexp.MustCompile("^Create"), - r: 4.2, - burst: 4, - }, - }, - appmesh.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 5, - }, - { - operationPtn: regexp.MustCompile("CreateMesh"), - r: 4.2, - burst: 6, - }, - }, - servicediscovery.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 7, - }, - }, - }, - }, - }, - { - name: "when val is empty", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "", - }, - wantErr: errors.Errorf(" must be formatted as serviceID:operationRegex=rate:burst"), - }, - { - name: "when val is not valid format - case 1", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a=b=c", - }, - wantErr: errors.Errorf("a=b=c must be formatted as serviceID:operationRegex=rate:burst"), - }, - { - name: "when val is not valid format - case 2", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a:b:c=4.2:5", - }, - wantErr: errors.Errorf("a:b:c must be formatted as serviceID:operationRegex"), - }, - { - name: "when val is not valid format - case 3", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a:b=4.2:5:6", - }, - wantErr: errors.Errorf("4.2:5:6 must be formatted as rate:burst"), - }, - { - name: "when operationPtn is not valid regex", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a:^[Describe=4.2:5", - }, - wantErr: errors.Errorf("^[Describe must be valid regex expression for operation"), - }, - { - name: "when rate is not valid float number", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a:^Describe=4.x:5", - }, - wantErr: errors.Errorf("4.x must be valid float number as rate for operations per second"), - }, - { - name: "when burst is not valid integer", - fields: fields{ - value: map[string][]throttleConfig{}, - }, - args: args{ - val: "a:^Describe=4.2:5x", - }, - wantErr: errors.Errorf("5x must be valid integer as burst for operations"), - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - c := &ServiceOperationsThrottleConfig{ - value: tt.fields.value, - } - err := c.Set(tt.args.val) - if tt.wantErr != nil { - assert.EqualError(t, err, tt.wantErr.Error()) - } else { - assert.NoError(t, err) - assert.Equal(t, tt.want, *c) - } - }) - } -} - -func TestServiceOperationsThrottleConfig_Type(t *testing.T) { - c := &ServiceOperationsThrottleConfig{} - got := c.Type() - assert.Equal(t, "serviceOperationsThrottleConfig", got) -} +// TODO : WIP +//import ( +// "github.com/aws/aws-sdk-go-v2/service/appmesh" +// "github.com/aws/aws-sdk-go-v2/service/servicediscovery" +// "github.com/stretchr/testify/assert" +// "regexp" +// "testing" +//) +// +//func TestServiceOperationsThrottleConfig_String(t *testing.T) { +// type fields struct { +// value map[string][]throttleConfig +// } +// tests := []struct { +// name string +// fields fields +// want string +// }{ +// { +// name: "non-empty value", +// fields: fields{ +// value: map[string][]throttleConfig{ +// appmesh.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 5, +// }, +// { +// operationPtn: regexp.MustCompile("CreateMesh"), +// r: 4.2, +// burst: 5, +// }, +// }, +// servicediscovery.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 5, +// }, +// }, +// }, +// }, +// want: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:5,ServiceDiscovery:^Describe=4.2:5", +// }, +// { +// name: "nil value", +// fields: fields{ +// value: nil, +// }, +// want: "", +// }, +// { +// name: "empty value", +// fields: fields{ +// value: nil, +// }, +// want: "", +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// c := &ServiceOperationsThrottleConfig{ +// value: tt.fields.value, +// } +// got := c.String() +// assert.Equal(t, tt.want, got) +// }) +// } +//} +// +//func TestServiceOperationsThrottleConfig_Set(t *testing.T) { +// type fields struct { +// value map[string][]throttleConfig +// } +// type args struct { +// val string +// } +// tests := []struct { +// name string +// fields fields +// args args +// want ServiceOperationsThrottleConfig +// wantErr error +// }{ +// { +// name: "when default value is nil", +// fields: fields{ +// value: nil, +// }, +// args: args{ +// val: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:6,ServiceDiscovery:^Describe=4.2:7", +// }, +// want: ServiceOperationsThrottleConfig{ +// value: map[string][]throttleConfig{ +// appmesh.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 5, +// }, +// { +// operationPtn: regexp.MustCompile("CreateMesh"), +// r: 4.2, +// burst: 6, +// }, +// }, +// servicediscovery.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 7, +// }, +// }, +// }, +// }, +// }, +// { +// name: "when default value contains non-empty defaults", +// fields: fields{ +// value: map[string][]throttleConfig{ +// elbv2.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Create"), +// r: 4.2, +// burst: 4, +// }, +// }, +// }, +// }, +// args: args{ +// val: "App Mesh:^Describe=4.2:5,App Mesh:CreateMesh=4.2:6,ServiceDiscovery:^Describe=4.2:7", +// }, +// want: ServiceOperationsThrottleConfig{ +// value: map[string][]throttleConfig{ +// elbv2.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Create"), +// r: 4.2, +// burst: 4, +// }, +// }, +// appmesh.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 5, +// }, +// { +// operationPtn: regexp.MustCompile("CreateMesh"), +// r: 4.2, +// burst: 6, +// }, +// }, +// servicediscovery.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 7, +// }, +// }, +// }, +// }, +// }, +// { +// name: "when val is empty", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "", +// }, +// wantErr: errors.Errorf(" must be formatted as serviceID:operationRegex=rate:burst"), +// }, +// { +// name: "when val is not valid format - case 1", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a=b=c", +// }, +// wantErr: errors.Errorf("a=b=c must be formatted as serviceID:operationRegex=rate:burst"), +// }, +// { +// name: "when val is not valid format - case 2", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a:b:c=4.2:5", +// }, +// wantErr: errors.Errorf("a:b:c must be formatted as serviceID:operationRegex"), +// }, +// { +// name: "when val is not valid format - case 3", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a:b=4.2:5:6", +// }, +// wantErr: errors.Errorf("4.2:5:6 must be formatted as rate:burst"), +// }, +// { +// name: "when operationPtn is not valid regex", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a:^[Describe=4.2:5", +// }, +// wantErr: errors.Errorf("^[Describe must be valid regex expression for operation"), +// }, +// { +// name: "when rate is not valid float number", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a:^Describe=4.x:5", +// }, +// wantErr: errors.Errorf("4.x must be valid float number as rate for operations per second"), +// }, +// { +// name: "when burst is not valid integer", +// fields: fields{ +// value: map[string][]throttleConfig{}, +// }, +// args: args{ +// val: "a:^Describe=4.2:5x", +// }, +// wantErr: errors.Errorf("5x must be valid integer as burst for operations"), +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t *testing.T) { +// c := &ServiceOperationsThrottleConfig{ +// value: tt.fields.value, +// } +// err := c.Set(tt.args.val) +// if tt.wantErr != nil { +// assert.EqualError(t, err, tt.wantErr.Error()) +// } else { +// assert.NoError(t, err) +// assert.Equal(t, tt.want, *c) +// } +// }) +// } +//} +// +//func TestServiceOperationsThrottleConfig_Type(t *testing.T) { +// c := &ServiceOperationsThrottleConfig{} +// got := c.Type() +// assert.Equal(t, "serviceOperationsThrottleConfig", got) +//} diff --git a/pkg/aws/throttle/defaults.go b/pkg/aws/throttle/defaults.go index 4d71a95849..29a1efc964 100644 --- a/pkg/aws/throttle/defaults.go +++ b/pkg/aws/throttle/defaults.go @@ -1,9 +1,9 @@ package throttle import ( - "github.com/aws/aws-sdk-go/service/elbv2" - "github.com/aws/aws-sdk-go/service/wafregional" - "github.com/aws/aws-sdk-go/service/wafv2" + "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + "github.com/aws/aws-sdk-go-v2/service/wafregional" + "github.com/aws/aws-sdk-go-v2/service/wafv2" "golang.org/x/time/rate" "regexp" ) @@ -36,7 +36,7 @@ func NewDefaultServiceOperationsThrottleConfig() *ServiceOperationsThrottleConfi burst: 1, }, }, - elbv2.ServiceID: { + elasticloadbalancingv2.ServiceID: { { operationPtn: regexp.MustCompile("^RegisterTargets|^DeregisterTargets"), r: rate.Limit(4), diff --git a/pkg/aws/throttle/throttler.go b/pkg/aws/throttle/throttler.go index 066cbec5c2..4b5a7b7ebd 100644 --- a/pkg/aws/throttle/throttler.go +++ b/pkg/aws/throttle/throttler.go @@ -1,70 +1,71 @@ package throttle -import ( - "github.com/aws/aws-sdk-go/aws/request" - "golang.org/x/time/rate" - "regexp" -) - -const sdkHandlerRequestThrottle = "requestThrottle" - -type conditionLimiter struct { - condition Condition - limiter *rate.Limiter -} - -type throttler struct { - conditionLimiters []conditionLimiter -} - -// NewThrottler constructs new request throttler instance. -func NewThrottler(config *ServiceOperationsThrottleConfig) *throttler { - throttler := &throttler{} - for serviceID, operationsThrottleConfigs := range config.value { - for _, operationsThrottleConfig := range operationsThrottleConfigs { - throttler = throttler.WithOperationPatternThrottle( - serviceID, - operationsThrottleConfig.operationPtn, - operationsThrottleConfig.r, - operationsThrottleConfig.burst) - } - } - return throttler -} - -func (t *throttler) WithConditionThrottle(condition Condition, r rate.Limit, burst int) *throttler { - limiter := rate.NewLimiter(r, burst) - t.conditionLimiters = append(t.conditionLimiters, conditionLimiter{ - condition: condition, - limiter: limiter, - }) - return t -} - -func (t *throttler) WithServiceThrottle(serviceID string, r rate.Limit, burst int) *throttler { - return t.WithConditionThrottle(matchService(serviceID), r, burst) -} - -func (t *throttler) WithOperationThrottle(serviceID string, operation string, r rate.Limit, burst int) *throttler { - return t.WithConditionThrottle(matchServiceOperation(serviceID, operation), r, burst) -} - -func (t *throttler) WithOperationPatternThrottle(serviceID string, operationPtn *regexp.Regexp, r rate.Limit, burst int) *throttler { - return t.WithConditionThrottle(matchServiceOperationPattern(serviceID, operationPtn), r, burst) -} - -func (t *throttler) InjectHandlers(handlers *request.Handlers) { - handlers.Sign.PushFrontNamed(request.NamedHandler{ - Name: sdkHandlerRequestThrottle, - Fn: t.beforeSign, - }) -} - -// beforeSign is added to the Sign chain; called before each request -func (t *throttler) beforeSign(r *request.Request) { - for _, conditionLimiter := range t.conditionLimiters { - if conditionLimiter.condition(r) { - conditionLimiter.limiter.Wait(r.Context()) - } - } -} +// TODO : WIP +//import ( +// "github.com/aws/aws-sdk-go/aws/request" +// "golang.org/x/time/rate" +// "regexp" +//) +// +//const sdkHandlerRequestThrottle = "requestThrottle" +// +//type conditionLimiter struct { +// condition Condition +// limiter *rate.Limiter +//} +// +//type throttler struct { +// conditionLimiters []conditionLimiter +//} +// +//// NewThrottler constructs new request throttler instance. +//func NewThrottler(config *ServiceOperationsThrottleConfig) *throttler { +// throttler := &throttler{} +// for serviceID, operationsThrottleConfigs := range config.value { +// for _, operationsThrottleConfig := range operationsThrottleConfigs { +// throttler = throttler.WithOperationPatternThrottle( +// serviceID, +// operationsThrottleConfig.operationPtn, +// operationsThrottleConfig.r, +// operationsThrottleConfig.burst) +// } +// } +// return throttler +//} +// +//func (t *throttler) WithConditionThrottle(condition Condition, r rate.Limit, burst int) *throttler { +// limiter := rate.NewLimiter(r, burst) +// t.conditionLimiters = append(t.conditionLimiters, conditionLimiter{ +// condition: condition, +// limiter: limiter, +// }) +// return t +//} +// +//func (t *throttler) WithServiceThrottle(serviceID string, r rate.Limit, burst int) *throttler { +// return t.WithConditionThrottle(matchService(serviceID), r, burst) +//} +// +//func (t *throttler) WithOperationThrottle(serviceID string, operation string, r rate.Limit, burst int) *throttler { +// return t.WithConditionThrottle(matchServiceOperation(serviceID, operation), r, burst) +//} +// +//func (t *throttler) WithOperationPatternThrottle(serviceID string, operationPtn *regexp.Regexp, r rate.Limit, burst int) *throttler { +// return t.WithConditionThrottle(matchServiceOperationPattern(serviceID, operationPtn), r, burst) +//} +// +//func (t *throttler) InjectHandlers(handlers *request.Handlers) { +// handlers.Sign.PushFrontNamed(request.NamedHandler{ +// Name: sdkHandlerRequestThrottle, +// Fn: t.beforeSign, +// }) +//} +// +//// beforeSign is added to the Sign chain; called before each request +//func (t *throttler) beforeSign(r *request.Request) { +// for _, conditionLimiter := range t.conditionLimiters { +// if conditionLimiter.condition(r) { +// conditionLimiter.limiter.Wait(r.Context()) +// } +// } +//} diff --git a/pkg/aws/throttle/throttler_test.go b/pkg/aws/throttle/throttler_test.go index 98b7526106..e52921b669 100644 --- a/pkg/aws/throttle/throttler_test.go +++ b/pkg/aws/throttle/throttler_test.go @@ -1,286 +1,285 @@ package throttle -import ( - "context" - "github.com/aws/aws-sdk-go/aws/client/metadata" - "github.com/aws/aws-sdk-go/aws/request" - "github.com/aws/aws-sdk-go/service/appmesh" - "github.com/aws/aws-sdk-go/service/servicediscovery" - "github.com/stretchr/testify/assert" - "golang.org/x/time/rate" - "net/http" - "regexp" - "sync" - "sync/atomic" - "testing" - "time" -) - -func Test_NewThrottler(t *testing.T) { - config := ServiceOperationsThrottleConfig{ - value: map[string][]throttleConfig{ - appmesh.ServiceID: { - { - operationPtn: regexp.MustCompile("^Describe"), - r: 4.2, - burst: 5, - }, - { - operationPtn: regexp.MustCompile("CreateMesh"), - r: 3.8, - burst: 4, - }, - }, - servicediscovery.ServiceID: { - { - operationPtn: regexp.MustCompile("^Create"), - r: 1.2, - burst: 2, - }, - }, - }, - } - - throttler := NewThrottler(&config) - assert.Equal(t, 3, len(throttler.conditionLimiters)) -} - -func Test_throttler_WithConditionThrottle(t *testing.T) { - throttler := &throttler{} - throttler.WithConditionThrottle(matchService(appmesh.ServiceID), 5.0, 10) - - assert.Equal(t, 1, len(throttler.conditionLimiters)) - - cl := throttler.conditionLimiters[0] - assert.True(t, cl.condition(&request.Request{ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}})) - assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) -} - -func Test_throttler_WithServiceThrottle(t *testing.T) { - throttler := &throttler{} - throttler.WithServiceThrottle(appmesh.ServiceID, 5.0, 10) - - assert.Equal(t, 1, len(throttler.conditionLimiters)) - - cl := throttler.conditionLimiters[0] - assert.True(t, cl.condition(&request.Request{ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}})) - assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) -} - -func Test_throttler_WithOperationThrottle(t *testing.T) { - throttler := &throttler{} - throttler.WithOperationThrottle(appmesh.ServiceID, "CreateMesh", 5.0, 10) - - assert.Equal(t, 1, len(throttler.conditionLimiters)) - - cl := throttler.conditionLimiters[0] - assert.True(t, cl.condition(&request.Request{ - ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}, - Operation: &request.Operation{Name: "CreateMesh"}, - })) - assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) -} - -func Test_throttler_WithOperationPatternThrottle(t *testing.T) { - throttler := &throttler{} - throttler.WithOperationPatternThrottle(appmesh.ServiceID, regexp.MustCompile("^Create"), 5.0, 10) - - assert.Equal(t, 1, len(throttler.conditionLimiters)) - - cl := throttler.conditionLimiters[0] - assert.True(t, cl.condition(&request.Request{ - ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}, - Operation: &request.Operation{Name: "CreateMesh"}, - })) - assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) -} - -func Test_throttler_InjectHandlers(t *testing.T) { - throttler := &throttler{} - handlers := request.Handlers{} - throttler.InjectHandlers(&handlers) - assert.Equal(t, 1, handlers.Sign.Len()) -} - -// Test beforeSign to check whether throttle applies correctly. -// Note: the validCallsCount checks whether the observed calls falls into [ideal-1, ideal+1] -// it shouldn't be too precisely to avoid false alarms caused by CPU load when running tests. -// structure your limits and testQPS, so that the expect QPS with/without throttle differs dramatically. (e.g. 10x) -func Test_throttler_beforeSign(t *testing.T) { - type fields struct { - conditionLimiters []conditionLimiter - } - type args struct { - r *request.Request - } - tests := []struct { - name string - fields fields - args args - testDuration time.Duration - testQPS int64 - validCallsCount func(elapsedDuration time.Duration, observedCallsCount int64) - }{ - { - name: "[single matching condition] throttle should applies", - fields: fields{ - conditionLimiters: []conditionLimiter{ - { - condition: func(r *request.Request) bool { - return true - }, - limiter: rate.NewLimiter(10, 5), - }, - }, - }, - args: args{ - r: &request.Request{ - HTTPRequest: &http.Request{}, - }, - }, - testQPS: 100, - validCallsCount: func(elapsedDuration time.Duration, count int64) { - ideal := 5 + 10*elapsedDuration.Seconds() - // We should never get more requests than allowed. - if want := int64(ideal * 1.1); count > want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - // We should get very close to the number of requests allowed. - if want := int64(ideal * 0.9); count < want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - }, - }, - { - name: "[single non-matching condition] throttle shouldn't applies", - fields: fields{ - conditionLimiters: []conditionLimiter{ - { - condition: func(r *request.Request) bool { - return false - }, - limiter: rate.NewLimiter(10, 5), - }, - }, - }, - args: args{ - r: &request.Request{ - HTTPRequest: &http.Request{}, - }, - }, - testQPS: 100, - validCallsCount: func(elapsedDuration time.Duration, count int64) { - ideal := 100 * elapsedDuration.Seconds() - // We should never get more requests than allowed. - if want := int64(ideal * 1.1); count > want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - // We should get very close to the number of requests allowed. - if want := int64(ideal * 0.9); count < want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - }, - }, - { - name: "[two condition, one matching and another non-matching] matching throttle should applies", - fields: fields{ - conditionLimiters: []conditionLimiter{ - { - condition: func(r *request.Request) bool { - return true - }, - limiter: rate.NewLimiter(10, 5), - }, - { - condition: func(r *request.Request) bool { - return false - }, - limiter: rate.NewLimiter(1, 5), - }, - }, - }, - args: args{ - r: &request.Request{ - HTTPRequest: &http.Request{}, - }, - }, - testQPS: 100, - validCallsCount: func(elapsedDuration time.Duration, count int64) { - ideal := 5 + 10*elapsedDuration.Seconds() - // We should never get more requests than allowed. - if want := int64(ideal * 1.1); count > want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - // We should get very close to the number of requests allowed. - if want := int64(ideal * 0.9); count < want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - }, - }, - { - name: "[two condition, both matching] most restrictive throttle should applies", - fields: fields{ - conditionLimiters: []conditionLimiter{ - { - condition: func(r *request.Request) bool { - return true - }, - limiter: rate.NewLimiter(10, 5), - }, - { - condition: func(r *request.Request) bool { - return true - }, - limiter: rate.NewLimiter(1, 5), - }, - }, - }, - args: args{ - r: &request.Request{ - HTTPRequest: &http.Request{}, - }, - }, - testQPS: 100, - validCallsCount: func(elapsedDuration time.Duration, count int64) { - ideal := 5 + 1*elapsedDuration.Seconds() - // We should never get more requests than allowed. - if want := int64(ideal * 1.1); count > want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - // We should get very close to the number of requests allowed. - if want := int64(ideal * 0.9); count < want { - t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) - } - }, - }, - } - for _, tt := range tests { - t.Run(tt.name, func(t1 *testing.T) { - throttler := &throttler{ - conditionLimiters: tt.fields.conditionLimiters, - } - - ctx, cancel := context.WithCancel(context.Background()) - tt.args.r.SetContext(ctx) - - observedCount := int64(0) - start := time.Now() - end := start.Add(time.Second * 1) - testQPSThrottle := time.Tick(time.Second / time.Duration(tt.testQPS)) - var wg sync.WaitGroup - for time.Now().Before(end) { - wg.Add(1) - go func() { - throttler.beforeSign(tt.args.r) - atomic.AddInt64(&observedCount, 1) - wg.Done() - }() - <-testQPSThrottle - } - elapsed := time.Since(start) - tt.validCallsCount(elapsed, atomic.LoadInt64(&observedCount)) - cancel() - wg.Wait() - }) - } -} +// TODO : WIP +//import ( +// "context" +// "github.com/aws/aws-sdk-go-v2/service/appmesh" +// "github.com/aws/aws-sdk-go-v2/service/servicediscovery" +// "github.com/stretchr/testify/assert" +// "golang.org/x/time/rate" +// "net/http" +// "regexp" +// "sync" +// "sync/atomic" +// "testing" +// "time" +//) +// +//func Test_NewThrottler(t *testing.T) { +// config := ServiceOperationsThrottleConfig{ +// value: map[string][]throttleConfig{ +// appmesh.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Describe"), +// r: 4.2, +// burst: 5, +// }, +// { +// operationPtn: regexp.MustCompile("CreateMesh"), +// r: 3.8, +// burst: 4, +// }, +// }, +// servicediscovery.ServiceID: { +// { +// operationPtn: regexp.MustCompile("^Create"), +// r: 1.2, +// burst: 2, +// }, +// }, +// }, +// } +// +// throttler := NewThrottler(&config) +// assert.Equal(t, 3, len(throttler.conditionLimiters)) +//} +// +//func Test_throttler_WithConditionThrottle(t *testing.T) { +// throttler := &throttler{} +// throttler.WithConditionThrottle(matchService(appmesh.ServiceID), 5.0, 10) +// +// assert.Equal(t, 1, len(throttler.conditionLimiters)) +// +// cl := throttler.conditionLimiters[0] +// assert.True(t, cl.condition(&request.Request{ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}})) +// assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) +//} +// +//func Test_throttler_WithServiceThrottle(t *testing.T) { +// throttler := &throttler{} +// throttler.WithServiceThrottle(appmesh.ServiceID, 5.0, 10) +// +// assert.Equal(t, 1, len(throttler.conditionLimiters)) +// +// cl := throttler.conditionLimiters[0] +// assert.True(t, cl.condition(&request.Request{ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}})) +// assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) +//} +// +//func Test_throttler_WithOperationThrottle(t *testing.T) { +// throttler := &throttler{} +// throttler.WithOperationThrottle(appmesh.ServiceID, "CreateMesh", 5.0, 10) +// +// assert.Equal(t, 1, len(throttler.conditionLimiters)) +// +// cl := throttler.conditionLimiters[0] +// assert.True(t, cl.condition(&request.Request{ +// ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}, +// Operation: &request.Operation{Name: "CreateMesh"}, +// })) +// assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) +//} +// +//func Test_throttler_WithOperationPatternThrottle(t *testing.T) { +// throttler := &throttler{} +// throttler.WithOperationPatternThrottle(appmesh.ServiceID, regexp.MustCompile("^Create"), 5.0, 10) +// +// assert.Equal(t, 1, len(throttler.conditionLimiters)) +// +// cl := throttler.conditionLimiters[0] +// assert.True(t, cl.condition(&request.Request{ +// ClientInfo: metadata.ClientInfo{ServiceID: appmesh.ServiceID}, +// Operation: &request.Operation{Name: "CreateMesh"}, +// })) +// assert.Equal(t, rate.NewLimiter(5.0, 10), cl.limiter) +//} +// +//func Test_throttler_InjectHandlers(t *testing.T) { +// throttler := &throttler{} +// handlers := request.Handlers{} +// throttler.InjectHandlers(&handlers) +// assert.Equal(t, 1, handlers.Sign.Len()) +//} +// +//// Test beforeSign to check whether throttle applies correctly. +//// Note: the validCallsCount checks whether the observed calls falls into [ideal-1, ideal+1] +//// it shouldn't be too precisely to avoid false alarms caused by CPU load when running tests. +//// structure your limits and testQPS, so that the expect QPS with/without throttle differs dramatically. (e.g. 10x) +//func Test_throttler_beforeSign(t *testing.T) { +// type fields struct { +// conditionLimiters []conditionLimiter +// } +// type args struct { +// r *request.Request +// } +// tests := []struct { +// name string +// fields fields +// args args +// testDuration time.Duration +// testQPS int64 +// validCallsCount func(elapsedDuration time.Duration, observedCallsCount int64) +// }{ +// { +// name: "[single matching condition] throttle should applies", +// fields: fields{ +// conditionLimiters: []conditionLimiter{ +// { +// condition: func(r *request.Request) bool { +// return true +// }, +// limiter: rate.NewLimiter(10, 5), +// }, +// }, +// }, +// args: args{ +// r: &request.Request{ +// HTTPRequest: &http.Request{}, +// }, +// }, +// testQPS: 100, +// validCallsCount: func(elapsedDuration time.Duration, count int64) { +// ideal := 5 + 10*elapsedDuration.Seconds() +// // We should never get more requests than allowed. +// if want := int64(ideal * 1.1); count > want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// // We should get very close to the number of requests allowed. +// if want := int64(ideal * 0.9); count < want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// }, +// }, +// { +// name: "[single non-matching condition] throttle shouldn't applies", +// fields: fields{ +// conditionLimiters: []conditionLimiter{ +// { +// condition: func(r *request.Request) bool { +// return false +// }, +// limiter: rate.NewLimiter(10, 5), +// }, +// }, +// }, +// args: args{ +// r: &request.Request{ +// HTTPRequest: &http.Request{}, +// }, +// }, +// testQPS: 100, +// validCallsCount: func(elapsedDuration time.Duration, count int64) { +// ideal := 100 * elapsedDuration.Seconds() +// // We should never get more requests than allowed. +// if want := int64(ideal * 1.1); count > want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// // We should get very close to the number of requests allowed. +// if want := int64(ideal * 0.9); count < want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// }, +// }, +// { +// name: "[two condition, one matching and another non-matching] matching throttle should applies", +// fields: fields{ +// conditionLimiters: []conditionLimiter{ +// { +// condition: func(r *request.Request) bool { +// return true +// }, +// limiter: rate.NewLimiter(10, 5), +// }, +// { +// condition: func(r *request.Request) bool { +// return false +// }, +// limiter: rate.NewLimiter(1, 5), +// }, +// }, +// }, +// args: args{ +// r: &request.Request{ +// HTTPRequest: &http.Request{}, +// }, +// }, +// testQPS: 100, +// validCallsCount: func(elapsedDuration time.Duration, count int64) { +// ideal := 5 + 10*elapsedDuration.Seconds() +// // We should never get more requests than allowed. +// if want := int64(ideal * 1.1); count > want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// // We should get very close to the number of requests allowed. +// if want := int64(ideal * 0.9); count < want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// }, +// }, +// { +// name: "[two condition, both matching] most restrictive throttle should applies", +// fields: fields{ +// conditionLimiters: []conditionLimiter{ +// { +// condition: func(r *request.Request) bool { +// return true +// }, +// limiter: rate.NewLimiter(10, 5), +// }, +// { +// condition: func(r *request.Request) bool { +// return true +// }, +// limiter: rate.NewLimiter(1, 5), +// }, +// }, +// }, +// args: args{ +// r: &request.Request{ +// HTTPRequest: &http.Request{}, +// }, +// }, +// testQPS: 100, +// validCallsCount: func(elapsedDuration time.Duration, count int64) { +// ideal := 5 + 1*elapsedDuration.Seconds() +// // We should never get more requests than allowed. +// if want := int64(ideal * 1.1); count > want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// // We should get very close to the number of requests allowed. +// if want := int64(ideal * 0.9); count < want { +// t.Errorf("count = %d, want %d (ideal %f", count, want, ideal) +// } +// }, +// }, +// } +// for _, tt := range tests { +// t.Run(tt.name, func(t1 *testing.T) { +// throttler := &throttler{ +// conditionLimiters: tt.fields.conditionLimiters, +// } +// +// ctx, cancel := context.WithCancel(context.Background()) +// tt.args.r.SetContext(ctx) +// +// observedCount := int64(0) +// start := time.Now() +// end := start.Add(time.Second * 1) +// testQPSThrottle := time.Tick(time.Second / time.Duration(tt.testQPS)) +// var wg sync.WaitGroup +// for time.Now().Before(end) { +// wg.Add(1) +// go func() { +// throttler.beforeSign(tt.args.r) +// atomic.AddInt64(&observedCount, 1) +// wg.Done() +// }() +// <-testQPSThrottle +// } +// elapsed := time.Since(start) +// tt.validCallsCount(elapsed, atomic.LoadInt64(&observedCount)) +// cancel() +// wg.Wait() +// }) +// } +//} diff --git a/pkg/aws/user_agent.go b/pkg/aws/user_agent.go deleted file mode 100644 index e7c6b8a2f3..0000000000 --- a/pkg/aws/user_agent.go +++ /dev/null @@ -1,17 +0,0 @@ -package aws - -import ( - "fmt" - "github.com/aws/aws-sdk-go/aws/request" - "sigs.k8s.io/aws-load-balancer-controller/pkg/version" -) - -const appName = "elbv2.k8s.aws" - -// injectUserAgent will inject app specific user-agent into awsSDK -func injectUserAgent(handlers *request.Handlers) { - handlers.Build.PushFrontNamed(request.NamedHandler{ - Name: fmt.Sprintf("%s/user-agent", appName), - Fn: request.MakeAddToUserAgentHandler(appName, version.GitVersion), - }) -} diff --git a/pkg/backend/endpoint_resolver.go b/pkg/backend/endpoint_resolver.go index 054e7abbb8..5e7fbedf73 100644 --- a/pkg/backend/endpoint_resolver.go +++ b/pkg/backend/endpoint_resolver.go @@ -4,7 +4,7 @@ import ( "context" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -147,10 +147,10 @@ func (r *defaultEndpointResolver) resolvePodEndpointsWithEndpointsData(ctx conte for _, epsData := range endpointsDataList { for _, port := range epsData.Ports { - if len(svcPort.Name) != 0 && svcPort.Name != awssdk.StringValue(port.Name) { + if len(svcPort.Name) != 0 && svcPort.Name != awssdk.ToString(port.Name) { continue } - epPort := awssdk.Int32Value(port.Port) + epPort := awssdk.ToInt32(port.Port) for _, ep := range epsData.Endpoints { if ep.TargetRef == nil || ep.TargetRef.Kind != "Pod" { continue @@ -284,7 +284,7 @@ func buildEndpointsDataFromEndpointSliceList(epsList *discovery.EndpointSliceLis func buildPodEndpoint(pod k8s.PodInfo, epAddr string, port int32) PodEndpoint { return PodEndpoint{ IP: epAddr, - Port: int64(port), + Port: awssdk.Int32(port), Pod: pod, } } @@ -292,7 +292,7 @@ func buildPodEndpoint(pod k8s.PodInfo, epAddr string, port int32) PodEndpoint { func buildNodePortEndpoint(node *corev1.Node, instanceID string, nodePort int32) NodePortEndpoint { return NodePortEndpoint{ InstanceID: instanceID, - Port: int64(nodePort), + Port: awssdk.Int32(nodePort), Node: node, } } diff --git a/pkg/backend/endpoint_resolver_test.go b/pkg/backend/endpoint_resolver_test.go index 27a01e7cce..e128f217b2 100644 --- a/pkg/backend/endpoint_resolver_test.go +++ b/pkg/backend/endpoint_resolver_test.go @@ -5,7 +5,7 @@ import ( "fmt" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" @@ -768,12 +768,12 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.1", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod1, }, { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -840,12 +840,12 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.1", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod1, }, { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -912,12 +912,12 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.1", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod1, }, { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -974,17 +974,17 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.2", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod2, }, { IP: "192.168.1.5", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod5, }, { IP: "192.168.1.8", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod8, }, }, @@ -1102,12 +1102,12 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.1", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod1, }, { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -1169,12 +1169,12 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.1", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod1, }, { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -1236,7 +1236,7 @@ func Test_defaultEndpointResolver_ResolvePodEndpoints(t *testing.T) { want: []PodEndpoint{ { IP: "192.168.1.4", - Port: 8080, + Port: awssdk.Int32(8080), Pod: pod4, }, }, @@ -1539,12 +1539,12 @@ func Test_defaultEndpointResolver_ResolveNodePortEndpoints(t *testing.T) { want: []NodePortEndpoint{ { InstanceID: "i-abcdefg1", - Port: 18080, + Port: awssdk.Int32(18080), Node: node1, }, { InstanceID: "i-abcdefg2", - Port: 18080, + Port: awssdk.Int32(18080), Node: node2, }, }, @@ -1566,12 +1566,12 @@ func Test_defaultEndpointResolver_ResolveNodePortEndpoints(t *testing.T) { want: []NodePortEndpoint{ { InstanceID: "i-abcdefg1", - Port: 18080, + Port: awssdk.Int32(18080), Node: node1, }, { InstanceID: "i-abcdefg2", - Port: 18080, + Port: awssdk.Int32(18080), Node: node2, }, }, @@ -1593,12 +1593,12 @@ func Test_defaultEndpointResolver_ResolveNodePortEndpoints(t *testing.T) { want: []NodePortEndpoint{ { InstanceID: "i-abcdefg3", - Port: 18080, + Port: awssdk.Int32(18080), Node: node3, }, { InstanceID: "i-abcdefg4", - Port: 18080, + Port: awssdk.Int32(18080), Node: node4, }, }, @@ -1633,7 +1633,7 @@ func Test_defaultEndpointResolver_ResolveNodePortEndpoints(t *testing.T) { want: []NodePortEndpoint{ { InstanceID: "i-abcdefg1", - Port: 18080, + Port: awssdk.Int32(18080), Node: node1, }, }, @@ -2609,7 +2609,7 @@ func Test_buildPodEndpoint(t *testing.T) { }, want: PodEndpoint{ IP: "192.168.1.1", - Port: 80, + Port: awssdk.Int32(80), Pod: k8s.PodInfo{ Key: types.NamespacedName{Name: "sample-node"}, }, @@ -2653,7 +2653,7 @@ func Test_buildNodePortEndpoint(t *testing.T) { }, }, InstanceID: "i-xxxxx", - Port: 33382, + Port: awssdk.Int32(33382), }, }, } diff --git a/pkg/backend/endpoint_types.go b/pkg/backend/endpoint_types.go index 76d017bd5f..bacfd46884 100644 --- a/pkg/backend/endpoint_types.go +++ b/pkg/backend/endpoint_types.go @@ -12,7 +12,7 @@ type PodEndpoint struct { // Pod's IP. IP string // Pod's container port. - Port int64 + Port *int32 // Pod that provides this endpoint. Pod k8s.PodInfo } @@ -22,7 +22,7 @@ type NodePortEndpoint struct { // Node's instanceID. InstanceID string // Node's NodePort. - Port int64 + Port *int32 // Node that provides this endpoint. Node *corev1.Node } diff --git a/pkg/deploy/ec2/security_group_manager.go b/pkg/deploy/ec2/security_group_manager.go index 64082ae142..59771d3616 100644 --- a/pkg/deploy/ec2/security_group_manager.go +++ b/pkg/deploy/ec2/security_group_manager.go @@ -2,9 +2,10 @@ package ec2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go" "github.com/go-logr/logr" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -72,9 +73,9 @@ func (m *defaultSecurityGroupManager) Create(ctx context.Context, resSG *ec2mode VpcId: awssdk.String(m.vpcID), GroupName: awssdk.String(resSG.Spec.GroupName), Description: awssdk.String(resSG.Spec.Description), - TagSpecifications: []*ec2sdk.TagSpecification{ + TagSpecifications: []ec2types.TagSpecification{ { - ResourceType: awssdk.String("security-group"), + ResourceType: "security-group", Tags: sdkTags, }, }, @@ -85,7 +86,7 @@ func (m *defaultSecurityGroupManager) Create(ctx context.Context, resSG *ec2mode if err != nil { return ec2model.SecurityGroupStatus{}, err } - sgID := awssdk.StringValue(resp.GroupId) + sgID := awssdk.ToString(resp.GroupId) m.logger.Info("created securityGroup", "resourceID", resSG.ID(), "securityGroupID", sgID) @@ -176,9 +177,9 @@ func buildIPPermissionInfo(permission ec2model.IPPermission) (networking.IPPermi } func isSecurityGroupDependencyViolationError(err error) bool { - var awsErr awserr.Error - if errors.As(err, &awsErr) { - return awsErr.Code() == "DependencyViolation" + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + return apiErr.ErrorCode() == "DependencyViolation" } return false } diff --git a/pkg/deploy/ec2/security_group_manager_test.go b/pkg/deploy/ec2/security_group_manager_test.go index ccf42eadeb..1ddbee5738 100644 --- a/pkg/deploy/ec2/security_group_manager_test.go +++ b/pkg/deploy/ec2/security_group_manager_test.go @@ -1,7 +1,7 @@ package ec2 import ( - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/smithy-go" "github.com/pkg/errors" "github.com/stretchr/testify/assert" "testing" @@ -19,14 +19,14 @@ func Test_isSecurityGroupDependencyViolationError(t *testing.T) { { name: "is DependencyViolation error", args: args{ - err: awserr.New("DependencyViolation", "some message", nil), + err: &smithy.GenericAPIError{Code: "DependencyViolation", Message: "some message"}, }, want: true, }, { name: "wraps DependencyViolation error", args: args{ - err: errors.Wrap(awserr.New("DependencyViolation", "some message", nil), "wrapped message"), + err: errors.Wrap(&smithy.GenericAPIError{Code: "DependencyViolation", Message: "some message"}, "wrapped message"), }, want: true, }, diff --git a/pkg/deploy/ec2/tagging_manager.go b/pkg/deploy/ec2/tagging_manager.go index e972c2029b..88067d7c20 100644 --- a/pkg/deploy/ec2/tagging_manager.go +++ b/pkg/deploy/ec2/tagging_manager.go @@ -4,8 +4,9 @@ import ( "context" "errors" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" @@ -96,7 +97,7 @@ func (m *defaultTaggingManager) ReconcileTags(ctx context.Context, resID string, if len(tagsToUpdate) > 0 { req := &ec2sdk.CreateTagsInput{ - Resources: []*string{awssdk.String(resID)}, + Resources: []string{resID}, Tags: convertTagsToSDKTags(tagsToUpdate), } @@ -112,7 +113,7 @@ func (m *defaultTaggingManager) ReconcileTags(ctx context.Context, resID string, if len(tagsToRemove) > 0 { req := &ec2sdk.DeleteTagsInput{ - Resources: []*string{awssdk.String(resID)}, + Resources: []string{resID}, Tags: convertTagsToSDKTags(tagsToRemove), } @@ -149,41 +150,41 @@ func (m *defaultTaggingManager) ListSecurityGroups(ctx context.Context, tagFilte func (m *defaultTaggingManager) listSecurityGroupsWithTagFilter(ctx context.Context, tagFilter tracking.TagFilter) (map[string]networking.SecurityGroupInfo, error) { req := &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{m.vpcID}), + Values: []string{m.vpcID}, }, }, } for _, tagKey := range sets.StringKeySet(tagFilter).List() { tagValues := tagFilter[tagKey] - var filter ec2sdk.Filter + var filter ec2types.Filter if len(tagValues) == 0 { tagFilterName := "tag-key" filter.Name = awssdk.String(tagFilterName) - filter.Values = awssdk.StringSlice([]string{tagKey}) + filter.Values = []string{tagKey} } else { tagFilterName := fmt.Sprintf("tag:%v", tagKey) filter.Name = awssdk.String(tagFilterName) - filter.Values = awssdk.StringSlice(tagValues) + filter.Values = tagValues } - req.Filters = append(req.Filters, &filter) + req.Filters = append(req.Filters, filter) } return m.networkingSGManager.FetchSGInfosByRequest(ctx, req) } // convert tags into AWS SDK tag presentation. -func convertTagsToSDKTags(tags map[string]string) []*ec2sdk.Tag { +func convertTagsToSDKTags(tags map[string]string) []ec2types.Tag { if len(tags) == 0 { return nil } - sdkTags := make([]*ec2sdk.Tag, 0, len(tags)) + sdkTags := make([]ec2types.Tag, 0, len(tags)) for _, key := range sets.StringKeySet(tags).List() { - sdkTags = append(sdkTags, &ec2sdk.Tag{ + sdkTags = append(sdkTags, ec2types.Tag{ Key: awssdk.String(key), Value: awssdk.String(tags[key]), }) diff --git a/pkg/deploy/ec2/tagging_manager_test.go b/pkg/deploy/ec2/tagging_manager_test.go index d346d7b0b6..9a4a04efba 100644 --- a/pkg/deploy/ec2/tagging_manager_test.go +++ b/pkg/deploy/ec2/tagging_manager_test.go @@ -2,10 +2,11 @@ package ec2 import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" @@ -50,8 +51,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { createTagsWithContextCalls: []createTagsWithContextCall{ { req: &ec2sdk.CreateTagsInput{ - Resources: awssdk.StringSlice([]string{"sg-a"}), - Tags: []*ec2sdk.Tag{ + Resources: []string{"sg-a"}, + Tags: []ec2types.Tag{ { Key: awssdk.String("keyB"), Value: awssdk.String("valueB2"), @@ -67,8 +68,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { deleteTagsWithContextCalls: []deleteTagsWithContextCall{ { req: &ec2sdk.DeleteTagsInput{ - Resources: awssdk.StringSlice([]string{"sg-a"}), - Tags: []*ec2sdk.Tag{ + Resources: []string{"sg-a"}, + Tags: []ec2types.Tag{ { Key: awssdk.String("keyC"), Value: awssdk.String("valueC"), @@ -101,8 +102,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { createTagsWithContextCalls: []createTagsWithContextCall{ { req: &ec2sdk.CreateTagsInput{ - Resources: awssdk.StringSlice([]string{"sg-a"}), - Tags: []*ec2sdk.Tag{ + Resources: []string{"sg-a"}, + Tags: []ec2types.Tag{ { Key: awssdk.String("keyC"), Value: awssdk.String("valueC2"), @@ -118,8 +119,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { deleteTagsWithContextCalls: []deleteTagsWithContextCall{ { req: &ec2sdk.DeleteTagsInput{ - Resources: awssdk.StringSlice([]string{"sg-a"}), - Tags: []*ec2sdk.Tag{ + Resources: []string{"sg-a"}, + Tags: []ec2types.Tag{ { Key: awssdk.String("keyF"), Value: awssdk.String("valueF"), @@ -200,22 +201,22 @@ func Test_defaultTaggingManager_ListSecurityGroups(t *testing.T) { fetchSGInfosByRequestCalls: []fetchSGInfosByRequestCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-xxxxxxx"}), + Values: []string{"vpc-xxxxxxx"}, }, { Name: awssdk.String("tag:keyA"), - Values: awssdk.StringSlice([]string{"valueA"}), + Values: []string{"valueA"}, }, { Name: awssdk.String("tag:keyB"), - Values: awssdk.StringSlice([]string{"valueB1", "valueB2"}), + Values: []string{"valueB1", "valueB2"}, }, { Name: awssdk.String("tag-key"), - Values: awssdk.StringSlice([]string{"keyC"}), + Values: []string{"keyC"}, }, }, }, @@ -278,22 +279,22 @@ func Test_defaultTaggingManager_ListSecurityGroups(t *testing.T) { fetchSGInfosByRequestCalls: []fetchSGInfosByRequestCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-xxxxxxx"}), + Values: []string{"vpc-xxxxxxx"}, }, { Name: awssdk.String("tag:keyA"), - Values: awssdk.StringSlice([]string{"valueA"}), + Values: []string{"valueA"}, }, { Name: awssdk.String("tag:keyB"), - Values: awssdk.StringSlice([]string{"valueB1", "valueB2"}), + Values: []string{"valueB1", "valueB2"}, }, { Name: awssdk.String("tag-key"), - Values: awssdk.StringSlice([]string{"keyC"}), + Values: []string{"keyC"}, }, }, }, @@ -320,22 +321,22 @@ func Test_defaultTaggingManager_ListSecurityGroups(t *testing.T) { }, { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-xxxxxxx"}), + Values: []string{"vpc-xxxxxxx"}, }, { Name: awssdk.String("tag:keyA"), - Values: awssdk.StringSlice([]string{"valueA"}), + Values: []string{"valueA"}, }, { Name: awssdk.String("tag:keyB"), - Values: awssdk.StringSlice([]string{"valueB2", "valueB3"}), + Values: []string{"valueB2", "valueB3"}, }, { Name: awssdk.String("tag-key"), - Values: awssdk.StringSlice([]string{"keyC"}), + Values: []string{"keyC"}, }, }, }, @@ -441,7 +442,7 @@ func Test_convertTagsToSDKTags(t *testing.T) { tests := []struct { name string args args - want []*ec2sdk.Tag + want []ec2types.Tag }{ { name: "non-empty tags", @@ -451,7 +452,7 @@ func Test_convertTagsToSDKTags(t *testing.T) { "keyB": "valueB", }, }, - want: []*ec2sdk.Tag{ + want: []ec2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), diff --git a/pkg/deploy/elbv2/listener_manager.go b/pkg/deploy/elbv2/listener_manager.go index 44b2308d51..2f635e5357 100644 --- a/pkg/deploy/elbv2/listener_manager.go +++ b/pkg/deploy/elbv2/listener_manager.go @@ -2,11 +2,12 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "reflect" "time" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" @@ -77,13 +78,13 @@ func (m *defaultListenerManager) Create(ctx context.Context, resLS *elbv2model.L return elbv2model.ListenerStatus{}, err } sdkLS := ListenerWithTags{ - Listener: resp.Listeners[0], + Listener: &resp.Listeners[0], Tags: lsTags, } m.logger.Info("created listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn)) + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn)) if err := runtime.RetryImmediateOnError(m.waitLSExistencePollInterval, m.waitLSExistenceTimeout, isListenerNotFoundError, func() error { return m.updateSDKListenerWithExtraCertificates(ctx, resLS, sdkLS, true) @@ -113,18 +114,18 @@ func (m *defaultListenerManager) Delete(ctx context.Context, sdkLS ListenerWithT ListenerArn: sdkLS.Listener.ListenerArn, } m.logger.Info("deleting listener", - "arn", awssdk.StringValue(req.ListenerArn)) + "arn", awssdk.ToString(req.ListenerArn)) if _, err := m.elbv2Client.DeleteListenerWithContext(ctx, req); err != nil { return err } m.logger.Info("deleted listener", - "arn", awssdk.StringValue(req.ListenerArn)) + "arn", awssdk.ToString(req.ListenerArn)) return nil } func (m *defaultListenerManager) updateSDKListenerWithTags(ctx context.Context, resLS *elbv2model.Listener, sdkLS ListenerWithTags) error { desiredLSTags := m.trackingProvider.ResourceTags(resLS.Stack(), resLS, resLS.Spec.Tags) - return m.taggingManager.ReconcileTags(ctx, awssdk.StringValue(sdkLS.Listener.ListenerArn), desiredLSTags, + return m.taggingManager.ReconcileTags(ctx, awssdk.ToString(sdkLS.Listener.ListenerArn), desiredLSTags, WithCurrentTags(sdkLS.Tags), WithIgnoredTagKeys(m.externalManagedTags)) } @@ -144,14 +145,14 @@ func (m *defaultListenerManager) updateSDKListenerWithSettings(ctx context.Conte m.logger.Info("modifying listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn)) + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn)) if _, err := m.elbv2Client.ModifyListenerWithContext(ctx, req); err != nil { return err } m.logger.Info("modified listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn)) + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn)) return nil } @@ -168,7 +169,7 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont desiredExtraCertARNs := sets.NewString() _, desiredExtraCerts := buildSDKCertificates(resLS.Spec.Certificates) for _, cert := range desiredExtraCerts { - desiredExtraCertARNs.Insert(awssdk.StringValue(cert.CertificateArn)) + desiredExtraCertARNs.Insert(awssdk.ToString(cert.CertificateArn)) } currentExtraCertARNs := sets.NewString() if !isNewSDKListener { @@ -182,7 +183,7 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont for _, certARN := range currentExtraCertARNs.Difference(desiredExtraCertARNs).List() { req := &elbv2sdk.RemoveListenerCertificatesInput{ ListenerArn: sdkLS.Listener.ListenerArn, - Certificates: []*elbv2sdk.Certificate{ + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String(certARN), }, @@ -191,7 +192,7 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont m.logger.Info("removing certificate from listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn), + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn), "certificateARN", certARN) if _, err := m.elbv2Client.RemoveListenerCertificatesWithContext(ctx, req); err != nil { return err @@ -199,14 +200,14 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont m.logger.Info("removed certificate from listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn), + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn), "certificateARN", certARN) } for _, certARN := range desiredExtraCertARNs.Difference(currentExtraCertARNs).List() { req := &elbv2sdk.AddListenerCertificatesInput{ ListenerArn: sdkLS.Listener.ListenerArn, - Certificates: []*elbv2sdk.Certificate{ + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String(certARN), }, @@ -215,7 +216,7 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont m.logger.Info("adding certificate to listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn), + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn), "certificateARN", certARN) if _, err := m.elbv2Client.AddListenerCertificatesWithContext(ctx, req); err != nil { return err @@ -223,7 +224,7 @@ func (m *defaultListenerManager) updateSDKListenerWithExtraCertificates(ctx cont m.logger.Info("added certificate to listener", "stackID", resLS.Stack().StackID(), "resourceID", resLS.ID(), - "arn", awssdk.StringValue(sdkLS.Listener.ListenerArn), + "arn", awssdk.ToString(sdkLS.Listener.ListenerArn), "certificateARN", certARN) } @@ -240,19 +241,19 @@ func (m *defaultListenerManager) fetchSDKListenerExtraCertificateARNs(ctx contex } extraCertARNs := make([]string, 0, len(sdkCerts)) for _, cert := range sdkCerts { - if !awssdk.BoolValue(cert.IsDefault) { - extraCertARNs = append(extraCertARNs, awssdk.StringValue(cert.CertificateArn)) + if !awssdk.ToBool(cert.IsDefault) { + extraCertARNs = append(extraCertARNs, awssdk.ToString(cert.CertificateArn)) } } return extraCertARNs, nil } func isSDKListenerSettingsDrifted(lsSpec elbv2model.ListenerSpec, sdkLS ListenerWithTags, - desiredDefaultActions []*elbv2sdk.Action, desiredDefaultCerts []*elbv2sdk.Certificate, desiredDefaultMutualAuthentication *elbv2sdk.MutualAuthenticationAttributes) bool { - if lsSpec.Port != awssdk.Int64Value(sdkLS.Listener.Port) { + desiredDefaultActions []elbv2types.Action, desiredDefaultCerts []elbv2types.Certificate, desiredDefaultMutualAuthentication *elbv2types.MutualAuthenticationAttributes) bool { + if lsSpec.Port != awssdk.ToInt32(sdkLS.Listener.Port) { return true } - if string(lsSpec.Protocol) != awssdk.StringValue(sdkLS.Listener.Protocol) { + if string(lsSpec.Protocol) != string(sdkLS.Listener.Protocol) { return true } if !cmp.Equal(desiredDefaultActions, sdkLS.Listener.DefaultActions, elbv2equality.CompareOptionForActions()) { @@ -261,10 +262,10 @@ func isSDKListenerSettingsDrifted(lsSpec elbv2model.ListenerSpec, sdkLS Listener if !cmp.Equal(desiredDefaultCerts, sdkLS.Listener.Certificates, elbv2equality.CompareOptionForCertificates()) { return true } - if lsSpec.SSLPolicy != nil && awssdk.StringValue(lsSpec.SSLPolicy) != awssdk.StringValue(sdkLS.Listener.SslPolicy) { + if lsSpec.SSLPolicy != nil && awssdk.ToString(lsSpec.SSLPolicy) != awssdk.ToString(sdkLS.Listener.SslPolicy) { return true } - if len(lsSpec.ALPNPolicy) != 0 && !cmp.Equal(lsSpec.ALPNPolicy, awssdk.StringValueSlice(sdkLS.Listener.AlpnPolicy), cmpopts.EquateEmpty()) { + if len(lsSpec.ALPNPolicy) != 0 && !cmp.Equal(lsSpec.ALPNPolicy, sdkLS.Listener.AlpnPolicy, cmpopts.EquateEmpty()) { return true } if desiredDefaultMutualAuthentication != nil && !reflect.DeepEqual(desiredDefaultMutualAuthentication, sdkLS.Listener.MutualAuthentication) { @@ -282,8 +283,8 @@ func buildSDKCreateListenerInput(lsSpec elbv2model.ListenerSpec, featureGates co } sdkObj := &elbv2sdk.CreateListenerInput{} sdkObj.LoadBalancerArn = awssdk.String(lbARN) - sdkObj.Port = awssdk.Int64(lsSpec.Port) - sdkObj.Protocol = awssdk.String(string(lsSpec.Protocol)) + sdkObj.Port = awssdk.Int32(lsSpec.Port) + sdkObj.Protocol = elbv2types.ProtocolEnum(lsSpec.Protocol) defaultActions, err := buildSDKActions(lsSpec.DefaultActions, featureGates) if err != nil { return nil, err @@ -292,22 +293,22 @@ func buildSDKCreateListenerInput(lsSpec elbv2model.ListenerSpec, featureGates co sdkObj.Certificates, _ = buildSDKCertificates(lsSpec.Certificates) sdkObj.SslPolicy = lsSpec.SSLPolicy if len(lsSpec.ALPNPolicy) != 0 { - sdkObj.AlpnPolicy = awssdk.StringSlice(lsSpec.ALPNPolicy) + sdkObj.AlpnPolicy = lsSpec.ALPNPolicy } sdkObj.MutualAuthentication = buildSDKMutualAuthenticationConfig(lsSpec.MutualAuthentication) return sdkObj, nil } -func buildSDKModifyListenerInput(lsSpec elbv2model.ListenerSpec, desiredDefaultActions []*elbv2sdk.Action, desiredDefaultCerts []*elbv2sdk.Certificate) *elbv2sdk.ModifyListenerInput { +func buildSDKModifyListenerInput(lsSpec elbv2model.ListenerSpec, desiredDefaultActions []elbv2types.Action, desiredDefaultCerts []elbv2types.Certificate) *elbv2sdk.ModifyListenerInput { sdkObj := &elbv2sdk.ModifyListenerInput{} - sdkObj.Port = awssdk.Int64(lsSpec.Port) - sdkObj.Protocol = awssdk.String(string(lsSpec.Protocol)) + sdkObj.Port = awssdk.Int32(lsSpec.Port) + sdkObj.Protocol = elbv2types.ProtocolEnum(lsSpec.Protocol) sdkObj.DefaultActions = desiredDefaultActions sdkObj.Certificates = desiredDefaultCerts sdkObj.SslPolicy = lsSpec.SSLPolicy if len(lsSpec.ALPNPolicy) != 0 { - sdkObj.AlpnPolicy = awssdk.StringSlice(lsSpec.ALPNPolicy) + sdkObj.AlpnPolicy = lsSpec.ALPNPolicy } sdkObj.MutualAuthentication = buildSDKMutualAuthenticationConfig(lsSpec.MutualAuthentication) @@ -316,13 +317,13 @@ func buildSDKModifyListenerInput(lsSpec elbv2model.ListenerSpec, desiredDefaultA // buildSDKCertificates builds the certificate list for listener. // returns the default certificates and extra certificates. -func buildSDKCertificates(modelCerts []elbv2model.Certificate) ([]*elbv2sdk.Certificate, []*elbv2sdk.Certificate) { +func buildSDKCertificates(modelCerts []elbv2model.Certificate) ([]elbv2types.Certificate, []elbv2types.Certificate) { if len(modelCerts) == 0 { return nil, nil } - var defaultSDKCerts []*elbv2sdk.Certificate - var extraSDKCerts []*elbv2sdk.Certificate + var defaultSDKCerts []elbv2types.Certificate + var extraSDKCerts []elbv2types.Certificate defaultSDKCerts = append(defaultSDKCerts, buildSDKCertificate(modelCerts[0])) for _, cert := range modelCerts[1:] { extraSDKCerts = append(extraSDKCerts, buildSDKCertificate(cert)) @@ -330,18 +331,18 @@ func buildSDKCertificates(modelCerts []elbv2model.Certificate) ([]*elbv2sdk.Cert return defaultSDKCerts, extraSDKCerts } -func buildSDKCertificate(modelCert elbv2model.Certificate) *elbv2sdk.Certificate { - return &elbv2sdk.Certificate{ +func buildSDKCertificate(modelCert elbv2model.Certificate) elbv2types.Certificate { + return elbv2types.Certificate{ CertificateArn: modelCert.CertificateARN, } } // buildSDKMutualAuthenticationConfig builds the mutual TLS authentication config for listener -func buildSDKMutualAuthenticationConfig(modelMutualAuthenticationCfg *elbv2model.MutualAuthenticationAttributes) *elbv2sdk.MutualAuthenticationAttributes { +func buildSDKMutualAuthenticationConfig(modelMutualAuthenticationCfg *elbv2model.MutualAuthenticationAttributes) *elbv2types.MutualAuthenticationAttributes { if modelMutualAuthenticationCfg == nil { return nil } - return &elbv2sdk.MutualAuthenticationAttributes{ + return &elbv2types.MutualAuthenticationAttributes{ IgnoreClientCertificateExpiry: modelMutualAuthenticationCfg.IgnoreClientCertificateExpiry, Mode: awssdk.String(modelMutualAuthenticationCfg.Mode), TrustStoreArn: modelMutualAuthenticationCfg.TrustStoreArn, @@ -350,6 +351,6 @@ func buildSDKMutualAuthenticationConfig(modelMutualAuthenticationCfg *elbv2model func buildResListenerStatus(sdkLS ListenerWithTags) elbv2model.ListenerStatus { return elbv2model.ListenerStatus{ - ListenerARN: awssdk.StringValue(sdkLS.Listener.ListenerArn), + ListenerARN: awssdk.ToString(sdkLS.Listener.ListenerArn), } } diff --git a/pkg/deploy/elbv2/listener_manager_test.go b/pkg/deploy/elbv2/listener_manager_test.go index d356c7f5c9..e096b500c0 100644 --- a/pkg/deploy/elbv2/listener_manager_test.go +++ b/pkg/deploy/elbv2/listener_manager_test.go @@ -1,8 +1,8 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/stretchr/testify/assert" elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" "testing" @@ -12,9 +12,9 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { type args struct { lsSpec elbv2model.ListenerSpec sdkLS ListenerWithTags - desiredDefaultActions []*elbv2sdk.Action - desiredDefaultCerts []*elbv2sdk.Certificate - desiredDefaultMutualAuthentication *elbv2sdk.MutualAuthenticationAttributes + desiredDefaultActions []elbv2types.Action + desiredDefaultCerts []elbv2types.Certificate + desiredDefaultMutualAuthentication *elbv2types.MutualAuthenticationAttributes } tests := []struct { name string @@ -31,45 +31,45 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { ALPNPolicy: []string{"HTTP2Preferred"}, }, sdkLS: ListenerWithTags{ - Listener: &elbv2sdk.Listener{ - Port: awssdk.Int64(80), - Protocol: awssdk.String("HTTPS"), - Certificates: []*elbv2sdk.Certificate{ + Listener: &elbv2types.Listener{ + Port: awssdk.Int32(80), + Protocol: elbv2types.ProtocolEnum("HTTPS"), + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - DefaultActions: []*elbv2sdk.Action{ + DefaultActions: []elbv2types.Action{ { - Type: awssdk.String("fixed-response"), - FixedResponseConfig: &elbv2sdk.FixedResponseActionConfig{ + Type: elbv2types.ActionTypeEnum("fixed-response"), + FixedResponseConfig: &elbv2types.FixedResponseActionConfig{ StatusCode: awssdk.String("404"), }, }, }, SslPolicy: awssdk.String("ELBSecurityPolicy-FS-1-2-Res-2019-08"), - AlpnPolicy: awssdk.StringSlice([]string{"HTTP2Preferred"}), - MutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + AlpnPolicy: []string{"HTTP2Preferred"}, + MutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, }, - desiredDefaultCerts: []*elbv2sdk.Certificate{ + desiredDefaultCerts: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - desiredDefaultActions: []*elbv2sdk.Action{ + desiredDefaultActions: []elbv2types.Action{ { - Type: awssdk.String("fixed-response"), - FixedResponseConfig: &elbv2sdk.FixedResponseActionConfig{ + Type: elbv2types.ActionTypeEnum("fixed-response"), + FixedResponseConfig: &elbv2types.FixedResponseActionConfig{ StatusCode: awssdk.String("404"), }, }, }, - desiredDefaultMutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + desiredDefaultMutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, @@ -92,45 +92,45 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, sdkLS: ListenerWithTags{ - Listener: &elbv2sdk.Listener{ - Port: awssdk.Int64(80), - Protocol: awssdk.String("HTTPS"), - Certificates: []*elbv2sdk.Certificate{ + Listener: &elbv2types.Listener{ + Port: awssdk.Int32(80), + Protocol: elbv2types.ProtocolEnum("HTTPS"), + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - DefaultActions: []*elbv2sdk.Action{ + DefaultActions: []elbv2types.Action{ { - Type: awssdk.String("fixed-response"), - FixedResponseConfig: &elbv2sdk.FixedResponseActionConfig{ + Type: elbv2types.ActionTypeEnum("fixed-response"), + FixedResponseConfig: &elbv2types.FixedResponseActionConfig{ StatusCode: awssdk.String("404"), }, }, }, SslPolicy: awssdk.String("ELBSecurityPolicy-FS-1-2-Res-2019-08"), - AlpnPolicy: awssdk.StringSlice([]string{"HTTP2Preferred"}), - MutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + AlpnPolicy: []string{"HTTP2Preferred"}, + MutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, }, - desiredDefaultCerts: []*elbv2sdk.Certificate{ + desiredDefaultCerts: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - desiredDefaultActions: []*elbv2sdk.Action{ + desiredDefaultActions: []elbv2types.Action{ { - Type: awssdk.String("fixed-response"), - FixedResponseConfig: &elbv2sdk.FixedResponseActionConfig{ + Type: elbv2types.ActionTypeEnum("fixed-response"), + FixedResponseConfig: &elbv2types.FixedResponseActionConfig{ StatusCode: awssdk.String("404"), }, }, }, - desiredDefaultMutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + desiredDefaultMutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, @@ -144,20 +144,20 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { SSLPolicy: awssdk.String("ELBSecurityPolicy-FS-1-2-Res-2019-08"), }, sdkLS: ListenerWithTags{ - Listener: &elbv2sdk.Listener{ - Port: awssdk.Int64(80), - Protocol: awssdk.String("HTTPS"), - Certificates: []*elbv2sdk.Certificate{ + Listener: &elbv2types.Listener{ + Port: awssdk.Int32(80), + Protocol: elbv2types.ProtocolEnum("HTTPS"), + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - DefaultActions: []*elbv2sdk.Action{ + DefaultActions: []elbv2types.Action{ { - Type: awssdk.String("forward-config"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward-config"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("target-group"), }, @@ -166,23 +166,23 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, SslPolicy: awssdk.String("ELBSecurityPolicy-FS-1-2-Res-2019-08"), - AlpnPolicy: awssdk.StringSlice([]string{"HTTP2Preferred"}), - MutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + AlpnPolicy: []string{"HTTP2Preferred"}, + MutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, }, - desiredDefaultCerts: []*elbv2sdk.Certificate{ + desiredDefaultCerts: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - desiredDefaultActions: []*elbv2sdk.Action{ + desiredDefaultActions: []elbv2types.Action{ { - Type: awssdk.String("forward-config"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward-config"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("target-group"), }, @@ -190,7 +190,7 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, }, - desiredDefaultMutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + desiredDefaultMutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("off"), }, }, @@ -208,20 +208,20 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, sdkLS: ListenerWithTags{ - Listener: &elbv2sdk.Listener{ - Port: awssdk.Int64(80), - Protocol: awssdk.String("HTTPS"), - Certificates: []*elbv2sdk.Certificate{ + Listener: &elbv2types.Listener{ + Port: awssdk.Int32(80), + Protocol: elbv2types.ProtocolEnum("HTTPS"), + Certificates: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - DefaultActions: []*elbv2sdk.Action{ + DefaultActions: []elbv2types.Action{ { - Type: awssdk.String("forward-config"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward-config"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("target-group"), }, @@ -230,25 +230,25 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, SslPolicy: awssdk.String("ELBSecurityPolicy-FS-1-2-Res-2019-08"), - AlpnPolicy: awssdk.StringSlice([]string{"HTTP2Preferred"}), - MutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + AlpnPolicy: []string{"HTTP2Preferred"}, + MutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("verify"), TrustStoreArn: awssdk.String("arn:aws:elasticloadbalancing:us-east-1:123456789123:truststore/ts-1/8786hghf"), IgnoreClientCertificateExpiry: awssdk.Bool(false), }, }, }, - desiredDefaultCerts: []*elbv2sdk.Certificate{ + desiredDefaultCerts: []elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-arn1"), IsDefault: awssdk.Bool(true), }, }, - desiredDefaultActions: []*elbv2sdk.Action{ + desiredDefaultActions: []elbv2types.Action{ { - Type: awssdk.String("forward-config"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward-config"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("target-group"), }, @@ -256,7 +256,7 @@ func Test_isSDKListenerSettingsDrifted(t *testing.T) { }, }, }, - desiredDefaultMutualAuthentication: &elbv2sdk.MutualAuthenticationAttributes{ + desiredDefaultMutualAuthentication: &elbv2types.MutualAuthenticationAttributes{ Mode: awssdk.String("verify"), TrustStoreArn: awssdk.String("arn:aws:elasticloadbalancing:us-east-1:123456789123:truststore/ts-1/8786hghf"), IgnoreClientCertificateExpiry: awssdk.Bool(false), diff --git a/pkg/deploy/elbv2/listener_rule_manager.go b/pkg/deploy/elbv2/listener_rule_manager.go index 2d80a0dc32..4efe82d724 100644 --- a/pkg/deploy/elbv2/listener_rule_manager.go +++ b/pkg/deploy/elbv2/listener_rule_manager.go @@ -2,8 +2,9 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "github.com/google/go-cmp/cmp" "github.com/pkg/errors" @@ -74,7 +75,7 @@ func (m *defaultListenerRuleManager) Create(ctx context.Context, resLR *elbv2mod return err } sdkLR = ListenerRuleWithTags{ - ListenerRule: resp.Rules[0], + ListenerRule: &resp.Rules[0], Tags: ruleTags, } return nil @@ -84,7 +85,7 @@ func (m *defaultListenerRuleManager) Create(ctx context.Context, resLR *elbv2mod m.logger.Info("created listener rule", "stackID", resLR.Stack().StackID(), "resourceID", resLR.ID(), - "arn", awssdk.StringValue(sdkLR.ListenerRule.RuleArn)) + "arn", awssdk.ToString(sdkLR.ListenerRule.RuleArn)) return buildResListenerRuleStatus(sdkLR), nil } @@ -106,12 +107,12 @@ func (m *defaultListenerRuleManager) Delete(ctx context.Context, sdkLR ListenerR RuleArn: sdkLR.ListenerRule.RuleArn, } m.logger.Info("deleting listener rule", - "arn", awssdk.StringValue(req.RuleArn)) + "arn", awssdk.ToString(req.RuleArn)) if _, err := m.elbv2Client.DeleteRuleWithContext(ctx, req); err != nil { return err } m.logger.Info("deleted listener rule", - "arn", awssdk.StringValue(req.RuleArn)) + "arn", awssdk.ToString(req.RuleArn)) return nil } @@ -130,26 +131,26 @@ func (m *defaultListenerRuleManager) updateSDKListenerRuleWithSettings(ctx conte m.logger.Info("modifying listener rule", "stackID", resLR.Stack().StackID(), "resourceID", resLR.ID(), - "arn", awssdk.StringValue(sdkLR.ListenerRule.RuleArn)) + "arn", awssdk.ToString(sdkLR.ListenerRule.RuleArn)) if _, err := m.elbv2Client.ModifyRuleWithContext(ctx, req); err != nil { return err } m.logger.Info("modified listener rule", "stackID", resLR.Stack().StackID(), "resourceID", resLR.ID(), - "arn", awssdk.StringValue(sdkLR.ListenerRule.RuleArn)) + "arn", awssdk.ToString(sdkLR.ListenerRule.RuleArn)) return nil } func (m *defaultListenerRuleManager) updateSDKListenerRuleWithTags(ctx context.Context, resLR *elbv2model.ListenerRule, sdkLR ListenerRuleWithTags) error { desiredTags := m.trackingProvider.ResourceTags(resLR.Stack(), resLR, resLR.Spec.Tags) - return m.taggingManager.ReconcileTags(ctx, awssdk.StringValue(sdkLR.ListenerRule.RuleArn), desiredTags, + return m.taggingManager.ReconcileTags(ctx, awssdk.ToString(sdkLR.ListenerRule.RuleArn), desiredTags, WithCurrentTags(sdkLR.Tags), WithIgnoredTagKeys(m.externalManagedTags)) } func isSDKListenerRuleSettingsDrifted(lrSpec elbv2model.ListenerRuleSpec, sdkLR ListenerRuleWithTags, - desiredActions []*elbv2sdk.Action, desiredConditions []*elbv2sdk.RuleCondition) bool { + desiredActions []elbv2types.Action, desiredConditions []elbv2types.RuleCondition) bool { if !cmp.Equal(desiredActions, sdkLR.ListenerRule.Actions, elbv2equality.CompareOptionForActions()) { return true @@ -169,7 +170,7 @@ func buildSDKCreateListenerRuleInput(lrSpec elbv2model.ListenerRuleSpec, feature } sdkObj := &elbv2sdk.CreateRuleInput{} sdkObj.ListenerArn = awssdk.String(lsARN) - sdkObj.Priority = awssdk.Int64(lrSpec.Priority) + sdkObj.Priority = awssdk.Int32(lrSpec.Priority) actions, err := buildSDKActions(lrSpec.Actions, featureGates) if err != nil { return nil, err @@ -179,7 +180,7 @@ func buildSDKCreateListenerRuleInput(lrSpec elbv2model.ListenerRuleSpec, feature return sdkObj, nil } -func buildSDKModifyListenerRuleInput(_ elbv2model.ListenerRuleSpec, desiredActions []*elbv2sdk.Action, desiredConditions []*elbv2sdk.RuleCondition) *elbv2sdk.ModifyRuleInput { +func buildSDKModifyListenerRuleInput(_ elbv2model.ListenerRuleSpec, desiredActions []elbv2types.Action, desiredConditions []elbv2types.RuleCondition) *elbv2sdk.ModifyRuleInput { sdkObj := &elbv2sdk.ModifyRuleInput{} sdkObj.Actions = desiredActions sdkObj.Conditions = desiredConditions @@ -188,6 +189,6 @@ func buildSDKModifyListenerRuleInput(_ elbv2model.ListenerRuleSpec, desiredActio func buildResListenerRuleStatus(sdkLR ListenerRuleWithTags) elbv2model.ListenerRuleStatus { return elbv2model.ListenerRuleStatus{ - RuleARN: awssdk.StringValue(sdkLR.ListenerRule.RuleArn), + RuleARN: awssdk.ToString(sdkLR.ListenerRule.RuleArn), } } diff --git a/pkg/deploy/elbv2/listener_rule_synthesizer.go b/pkg/deploy/elbv2/listener_rule_synthesizer.go index 98a7ef4273..99a9409367 100644 --- a/pkg/deploy/elbv2/listener_rule_synthesizer.go +++ b/pkg/deploy/elbv2/listener_rule_synthesizer.go @@ -2,7 +2,7 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -97,7 +97,7 @@ func (s *listenerRuleSynthesizer) findSDKListenersRulesOnLS(ctx context.Context, } nonDefaultRules := make([]ListenerRuleWithTags, 0, len(sdkLRs)) for _, rule := range sdkLRs { - if awssdk.BoolValue(rule.ListenerRule.IsDefault) { + if awssdk.ToBool(rule.ListenerRule.IsDefault) { continue } nonDefaultRules = append(nonDefaultRules, rule) @@ -117,8 +117,8 @@ func matchResAndSDKListenerRules(resLRs []*elbv2model.ListenerRule, sdkLRs []Lis resLRByPriority := mapResListenerRuleByPriority(resLRs) sdkLRByPriority := mapSDKListenerRuleByPriority(sdkLRs) - resLRPriorities := sets.Int64KeySet(resLRByPriority) - sdkLRPriorities := sets.Int64KeySet(sdkLRByPriority) + resLRPriorities := sets.Int32KeySet(resLRByPriority) + sdkLRPriorities := sets.Int32KeySet(sdkLRByPriority) for _, priority := range resLRPriorities.Intersection(sdkLRPriorities).List() { resLR := resLRByPriority[priority] sdkLR := sdkLRByPriority[priority] @@ -137,19 +137,19 @@ func matchResAndSDKListenerRules(resLRs []*elbv2model.ListenerRule, sdkLRs []Lis return matchedResAndSDKLRs, unmatchedResLRs, unmatchedSDKLRs } -func mapResListenerRuleByPriority(resLRs []*elbv2model.ListenerRule) map[int64]*elbv2model.ListenerRule { - resLRByPriority := make(map[int64]*elbv2model.ListenerRule, len(resLRs)) +func mapResListenerRuleByPriority(resLRs []*elbv2model.ListenerRule) map[int32]*elbv2model.ListenerRule { + resLRByPriority := make(map[int32]*elbv2model.ListenerRule, len(resLRs)) for _, resLR := range resLRs { resLRByPriority[resLR.Spec.Priority] = resLR } return resLRByPriority } -func mapSDKListenerRuleByPriority(sdkLRs []ListenerRuleWithTags) map[int64]ListenerRuleWithTags { - sdkLRByPriority := make(map[int64]ListenerRuleWithTags, len(sdkLRs)) +func mapSDKListenerRuleByPriority(sdkLRs []ListenerRuleWithTags) map[int32]ListenerRuleWithTags { + sdkLRByPriority := make(map[int32]ListenerRuleWithTags, len(sdkLRs)) for _, sdkLR := range sdkLRs { - priority, _ := strconv.ParseInt(awssdk.StringValue(sdkLR.ListenerRule.Priority), 10, 64) - sdkLRByPriority[priority] = sdkLR + priority, _ := strconv.ParseInt(awssdk.ToString(sdkLR.ListenerRule.Priority), 10, 64) + sdkLRByPriority[int32(priority)] = sdkLR } return sdkLRByPriority } diff --git a/pkg/deploy/elbv2/listener_synthesizer.go b/pkg/deploy/elbv2/listener_synthesizer.go index e5a40db873..726d2178ca 100644 --- a/pkg/deploy/elbv2/listener_synthesizer.go +++ b/pkg/deploy/elbv2/listener_synthesizer.go @@ -2,7 +2,7 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -96,8 +96,8 @@ func matchResAndSDKListeners(resLSs []*elbv2model.Listener, sdkLSs []ListenerWit resLSByPort := mapResListenerByPort(resLSs) sdkLSByPort := mapSDKListenerByPort(sdkLSs) - resLSPorts := sets.Int64KeySet(resLSByPort) - sdkLSPorts := sets.Int64KeySet(sdkLSByPort) + resLSPorts := sets.Int32KeySet(resLSByPort) + sdkLSPorts := sets.Int32KeySet(sdkLSByPort) for _, port := range resLSPorts.Intersection(sdkLSPorts).List() { resLS := resLSByPort[port] sdkLS := sdkLSByPort[port] @@ -115,18 +115,18 @@ func matchResAndSDKListeners(resLSs []*elbv2model.Listener, sdkLSs []ListenerWit return matchedResAndSDKLSs, unmatchedResLSs, unmatchedSDKLSs } -func mapResListenerByPort(resLSs []*elbv2model.Listener) map[int64]*elbv2model.Listener { - resLSByPort := make(map[int64]*elbv2model.Listener, len(resLSs)) +func mapResListenerByPort(resLSs []*elbv2model.Listener) map[int32]*elbv2model.Listener { + resLSByPort := make(map[int32]*elbv2model.Listener, len(resLSs)) for _, ls := range resLSs { resLSByPort[ls.Spec.Port] = ls } return resLSByPort } -func mapSDKListenerByPort(sdkLSs []ListenerWithTags) map[int64]ListenerWithTags { - sdkLSByPort := make(map[int64]ListenerWithTags, len(sdkLSs)) +func mapSDKListenerByPort(sdkLSs []ListenerWithTags) map[int32]ListenerWithTags { + sdkLSByPort := make(map[int32]ListenerWithTags, len(sdkLSs)) for _, ls := range sdkLSs { - sdkLSByPort[awssdk.Int64Value(ls.Listener.Port)] = ls + sdkLSByPort[awssdk.ToInt32(ls.Listener.Port)] = ls } return sdkLSByPort } diff --git a/pkg/deploy/elbv2/listener_utils.go b/pkg/deploy/elbv2/listener_utils.go index 82f498968e..7191f5f23c 100644 --- a/pkg/deploy/elbv2/listener_utils.go +++ b/pkg/deploy/elbv2/listener_utils.go @@ -2,9 +2,9 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" + "github.com/aws/smithy-go" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/config" elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" @@ -16,27 +16,27 @@ const ( defaultWaitLSExistenceTimeout = 20 * time.Second ) -func buildSDKActions(modelActions []elbv2model.Action, featureGates config.FeatureGates) ([]*elbv2sdk.Action, error) { - var sdkActions []*elbv2sdk.Action +func buildSDKActions(modelActions []elbv2model.Action, featureGates config.FeatureGates) ([]elbv2types.Action, error) { + var sdkActions []elbv2types.Action if len(modelActions) != 0 { - sdkActions = make([]*elbv2sdk.Action, 0, len(modelActions)) + sdkActions = make([]elbv2types.Action, 0, len(modelActions)) for index, modelAction := range modelActions { sdkAction, err := buildSDKAction(modelAction, featureGates) if err != nil { return nil, err } - sdkAction.Order = awssdk.Int64(int64(index) + 1) + sdkAction.Order = awssdk.Int32(int32(index) + 1) sdkActions = append(sdkActions, sdkAction) } } return sdkActions, nil } -func buildSDKAction(modelAction elbv2model.Action, featureGates config.FeatureGates) (*elbv2sdk.Action, error) { - sdkObj := &elbv2sdk.Action{} - sdkObj.Type = awssdk.String(string(modelAction.Type)) +func buildSDKAction(modelAction elbv2model.Action, featureGates config.FeatureGates) (elbv2types.Action, error) { + sdkObj := elbv2types.Action{} + sdkObj.Type = elbv2types.ActionTypeEnum(modelAction.Type) if modelAction.AuthenticateCognitoConfig != nil { - sdkObj.AuthenticateCognitoConfig = buildSDKAuthenticateCognitoActionConfig(*modelAction.AuthenticateCognitoConfig) + sdkObj.AuthenticateCognitoConfig = buildSDKAuthenticateCognitoActionConfig(modelAction.AuthenticateCognitoConfig) } if modelAction.AuthenticateOIDCConfig != nil { sdkObj.AuthenticateOidcConfig = buildSDKAuthenticateOidcActionConfig(*modelAction.AuthenticateOIDCConfig) @@ -50,13 +50,13 @@ func buildSDKAction(modelAction elbv2model.Action, featureGates config.FeatureGa if modelAction.ForwardConfig != nil { forwardConfig, err := buildSDKForwardActionConfig(*modelAction.ForwardConfig) if err != nil { - return nil, err + return elbv2types.Action{}, err } if !featureGates.Enabled(config.WeightedTargetGroups) { if len(forwardConfig.TargetGroups) == 1 { sdkObj.TargetGroupArn = forwardConfig.TargetGroups[0].TargetGroupArn } else { - return nil, errors.New("weighted target groups feature is disabled") + return elbv2types.Action{}, errors.New("weighted target groups feature is disabled") } } else { sdkObj.ForwardConfig = forwardConfig @@ -65,10 +65,10 @@ func buildSDKAction(modelAction elbv2model.Action, featureGates config.FeatureGa return sdkObj, nil } -func buildSDKAuthenticateCognitoActionConfig(modelCfg elbv2model.AuthenticateCognitoActionConfig) *elbv2sdk.AuthenticateCognitoActionConfig { - return &elbv2sdk.AuthenticateCognitoActionConfig{ - AuthenticationRequestExtraParams: awssdk.StringMap(modelCfg.AuthenticationRequestExtraParams), - OnUnauthenticatedRequest: (*string)(modelCfg.OnUnauthenticatedRequest), +func buildSDKAuthenticateCognitoActionConfig(modelCfg *elbv2model.AuthenticateCognitoActionConfig) *elbv2types.AuthenticateCognitoActionConfig { + return &elbv2types.AuthenticateCognitoActionConfig{ + AuthenticationRequestExtraParams: modelCfg.AuthenticationRequestExtraParams, + OnUnauthenticatedRequest: elbv2types.AuthenticateCognitoActionConditionalBehaviorEnum(modelCfg.OnUnauthenticatedRequest), Scope: modelCfg.Scope, SessionCookieName: modelCfg.SessionCookieName, SessionTimeout: modelCfg.SessionTimeout, @@ -78,10 +78,10 @@ func buildSDKAuthenticateCognitoActionConfig(modelCfg elbv2model.AuthenticateCog } } -func buildSDKAuthenticateOidcActionConfig(modelCfg elbv2model.AuthenticateOIDCActionConfig) *elbv2sdk.AuthenticateOidcActionConfig { - return &elbv2sdk.AuthenticateOidcActionConfig{ - AuthenticationRequestExtraParams: awssdk.StringMap(modelCfg.AuthenticationRequestExtraParams), - OnUnauthenticatedRequest: (*string)(modelCfg.OnUnauthenticatedRequest), +func buildSDKAuthenticateOidcActionConfig(modelCfg elbv2model.AuthenticateOIDCActionConfig) *elbv2types.AuthenticateOidcActionConfig { + return &elbv2types.AuthenticateOidcActionConfig{ + AuthenticationRequestExtraParams: modelCfg.AuthenticationRequestExtraParams, + OnUnauthenticatedRequest: elbv2types.AuthenticateOidcActionConditionalBehaviorEnum(modelCfg.OnUnauthenticatedRequest), Scope: modelCfg.Scope, SessionCookieName: modelCfg.SessionCookieName, SessionTimeout: modelCfg.SessionTimeout, @@ -94,42 +94,42 @@ func buildSDKAuthenticateOidcActionConfig(modelCfg elbv2model.AuthenticateOIDCAc } } -func buildSDKFixedResponseActionConfig(modelCfg elbv2model.FixedResponseActionConfig) *elbv2sdk.FixedResponseActionConfig { - return &elbv2sdk.FixedResponseActionConfig{ +func buildSDKFixedResponseActionConfig(modelCfg elbv2model.FixedResponseActionConfig) *elbv2types.FixedResponseActionConfig { + return &elbv2types.FixedResponseActionConfig{ ContentType: modelCfg.ContentType, MessageBody: modelCfg.MessageBody, StatusCode: awssdk.String(modelCfg.StatusCode), } } -func buildSDKRedirectActionConfig(modelCfg elbv2model.RedirectActionConfig) *elbv2sdk.RedirectActionConfig { - return &elbv2sdk.RedirectActionConfig{ +func buildSDKRedirectActionConfig(modelCfg elbv2model.RedirectActionConfig) *elbv2types.RedirectActionConfig { + return &elbv2types.RedirectActionConfig{ Host: modelCfg.Host, Path: modelCfg.Path, Port: modelCfg.Port, Protocol: modelCfg.Protocol, Query: modelCfg.Query, - StatusCode: awssdk.String(modelCfg.StatusCode), + StatusCode: elbv2types.RedirectActionStatusCodeEnum(modelCfg.StatusCode), } } -func buildSDKForwardActionConfig(modelCfg elbv2model.ForwardActionConfig) (*elbv2sdk.ForwardActionConfig, error) { +func buildSDKForwardActionConfig(modelCfg elbv2model.ForwardActionConfig) (*elbv2types.ForwardActionConfig, error) { ctx := context.Background() - sdkObj := &elbv2sdk.ForwardActionConfig{} - var tgTuples []*elbv2sdk.TargetGroupTuple + sdkObj := &elbv2types.ForwardActionConfig{} + var tgTuples []elbv2types.TargetGroupTuple for _, tgt := range modelCfg.TargetGroups { tgARN, err := tgt.TargetGroupARN.Resolve(ctx) if err != nil { return nil, err } - tgTuples = append(tgTuples, &elbv2sdk.TargetGroupTuple{ + tgTuples = append(tgTuples, elbv2types.TargetGroupTuple{ TargetGroupArn: awssdk.String(tgARN), Weight: tgt.Weight, }) } sdkObj.TargetGroups = tgTuples if modelCfg.TargetGroupStickinessConfig != nil { - sdkObj.TargetGroupStickinessConfig = &elbv2sdk.TargetGroupStickinessConfig{ + sdkObj.TargetGroupStickinessConfig = &elbv2types.TargetGroupStickinessConfig{ DurationSeconds: modelCfg.TargetGroupStickinessConfig.DurationSeconds, Enabled: modelCfg.TargetGroupStickinessConfig.Enabled, } @@ -138,10 +138,10 @@ func buildSDKForwardActionConfig(modelCfg elbv2model.ForwardActionConfig) (*elbv return sdkObj, nil } -func buildSDKRuleConditions(modelConditions []elbv2model.RuleCondition) []*elbv2sdk.RuleCondition { - var sdkConditions []*elbv2sdk.RuleCondition +func buildSDKRuleConditions(modelConditions []elbv2model.RuleCondition) []elbv2types.RuleCondition { + var sdkConditions []elbv2types.RuleCondition if len(modelConditions) != 0 { - sdkConditions = make([]*elbv2sdk.RuleCondition, 0, len(modelConditions)) + sdkConditions = make([]elbv2types.RuleCondition, 0, len(modelConditions)) for _, modelCondition := range modelConditions { sdkCondition := buildSDKRuleCondition(modelCondition) sdkConditions = append(sdkConditions, sdkCondition) @@ -150,8 +150,8 @@ func buildSDKRuleConditions(modelConditions []elbv2model.RuleCondition) []*elbv2 return sdkConditions } -func buildSDKRuleCondition(modelCondition elbv2model.RuleCondition) *elbv2sdk.RuleCondition { - sdkObj := &elbv2sdk.RuleCondition{} +func buildSDKRuleCondition(modelCondition elbv2model.RuleCondition) elbv2types.RuleCondition { + sdkObj := elbv2types.RuleCondition{} sdkObj.Field = awssdk.String(string(modelCondition.Field)) if modelCondition.HostHeaderConfig != nil { sdkObj.HostHeaderConfig = buildSDKHostHeaderConditionConfig(*modelCondition.HostHeaderConfig) @@ -174,54 +174,60 @@ func buildSDKRuleCondition(modelCondition elbv2model.RuleCondition) *elbv2sdk.Ru return sdkObj } -func buildSDKHostHeaderConditionConfig(modelCfg elbv2model.HostHeaderConditionConfig) *elbv2sdk.HostHeaderConditionConfig { - return &elbv2sdk.HostHeaderConditionConfig{ - Values: awssdk.StringSlice(modelCfg.Values), +func buildSDKHostHeaderConditionConfig(modelCfg elbv2model.HostHeaderConditionConfig) *elbv2types.HostHeaderConditionConfig { + return &elbv2types.HostHeaderConditionConfig{ + Values: modelCfg.Values, } } -func buildSDKHTTPHeaderConditionConfig(modelCfg elbv2model.HTTPHeaderConditionConfig) *elbv2sdk.HttpHeaderConditionConfig { - return &elbv2sdk.HttpHeaderConditionConfig{ +func buildSDKHTTPHeaderConditionConfig(modelCfg elbv2model.HTTPHeaderConditionConfig) *elbv2types.HttpHeaderConditionConfig { + return &elbv2types.HttpHeaderConditionConfig{ HttpHeaderName: awssdk.String(modelCfg.HTTPHeaderName), - Values: awssdk.StringSlice(modelCfg.Values), + Values: modelCfg.Values, } } -func buildSDKHTTPRequestMethodConditionConfig(modelCfg elbv2model.HTTPRequestMethodConditionConfig) *elbv2sdk.HttpRequestMethodConditionConfig { - return &elbv2sdk.HttpRequestMethodConditionConfig{ - Values: awssdk.StringSlice(modelCfg.Values), +func buildSDKHTTPRequestMethodConditionConfig(modelCfg elbv2model.HTTPRequestMethodConditionConfig) *elbv2types.HttpRequestMethodConditionConfig { + return &elbv2types.HttpRequestMethodConditionConfig{ + Values: modelCfg.Values, } } -func buildSDKPathPatternConditionConfig(modelCfg elbv2model.PathPatternConditionConfig) *elbv2sdk.PathPatternConditionConfig { - return &elbv2sdk.PathPatternConditionConfig{ - Values: awssdk.StringSlice(modelCfg.Values), +func buildSDKPathPatternConditionConfig(modelCfg elbv2model.PathPatternConditionConfig) *elbv2types.PathPatternConditionConfig { + return &elbv2types.PathPatternConditionConfig{ + Values: modelCfg.Values, } } -func buildSDKQueryStringConditionConfig(modelCfg elbv2model.QueryStringConditionConfig) *elbv2sdk.QueryStringConditionConfig { - kvPairs := make([]*elbv2sdk.QueryStringKeyValuePair, 0, len(modelCfg.Values)) +func buildSDKQueryStringConditionConfig(modelCfg elbv2model.QueryStringConditionConfig) *elbv2types.QueryStringConditionConfig { + kvPairs := make([]elbv2types.QueryStringKeyValuePair, 0, len(modelCfg.Values)) for _, value := range modelCfg.Values { - kvPairs = append(kvPairs, &elbv2sdk.QueryStringKeyValuePair{ + kvPairs = append(kvPairs, elbv2types.QueryStringKeyValuePair{ Key: value.Key, Value: awssdk.String(value.Value), }) } - return &elbv2sdk.QueryStringConditionConfig{ + return &elbv2types.QueryStringConditionConfig{ Values: kvPairs, } } -func buildSDKSourceIpConditionConfig(modelCfg elbv2model.SourceIPConditionConfig) *elbv2sdk.SourceIpConditionConfig { - return &elbv2sdk.SourceIpConditionConfig{ - Values: awssdk.StringSlice(modelCfg.Values), +func buildSDKSourceIpConditionConfig(modelCfg elbv2model.SourceIPConditionConfig) *elbv2types.SourceIpConditionConfig { + return &elbv2types.SourceIpConditionConfig{ + Values: modelCfg.Values, } } func isListenerNotFoundError(err error) bool { - var awsErr awserr.Error + var awsErr *elbv2types.ListenerNotFoundException if errors.As(err, &awsErr) { - return awsErr.Code() == "ListenerNotFound" + return true + } + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + code := apiErr.ErrorCode() + + return code == "ResourceInUse" } return false } diff --git a/pkg/deploy/elbv2/listener_utils_test.go b/pkg/deploy/elbv2/listener_utils_test.go index f6a8d4ce72..1d4bcebe64 100644 --- a/pkg/deploy/elbv2/listener_utils_test.go +++ b/pkg/deploy/elbv2/listener_utils_test.go @@ -1,7 +1,7 @@ package elbv2 import ( - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/smithy-go" "github.com/pkg/errors" "github.com/stretchr/testify/assert" "testing" @@ -19,14 +19,14 @@ func Test_isListenerNotFoundError(t *testing.T) { { name: "is ListenerNotFound error", args: args{ - err: awserr.New("ListenerNotFound", "some message", nil), + err: &smithy.GenericAPIError{Code: "ListenerNotFound", Message: "some message"}, }, want: true, }, { name: "wraps ListenerNotFound error", args: args{ - err: errors.Wrap(awserr.New("ListenerNotFound", "some message", nil), "wrapped message"), + err: errors.Wrap(&smithy.GenericAPIError{Code: "ListenerNotFound", Message: "some message"}, "wrapped message"), }, want: true, }, diff --git a/pkg/deploy/elbv2/load_balancer_attributes_reconciler.go b/pkg/deploy/elbv2/load_balancer_attributes_reconciler.go index f2e4491b8b..0c0d8860e2 100644 --- a/pkg/deploy/elbv2/load_balancer_attributes_reconciler.go +++ b/pkg/deploy/elbv2/load_balancer_attributes_reconciler.go @@ -2,8 +2,9 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" @@ -47,7 +48,7 @@ func (r *defaultLoadBalancerAttributeReconciler) Reconcile(ctx context.Context, Attributes: nil, } for _, attrKey := range sets.StringKeySet(attributesToUpdate).List() { - req.Attributes = append(req.Attributes, &elbv2sdk.LoadBalancerAttribute{ + req.Attributes = append(req.Attributes, elbv2types.LoadBalancerAttribute{ Key: awssdk.String(attrKey), Value: awssdk.String(attributesToUpdate[attrKey]), }) @@ -56,7 +57,7 @@ func (r *defaultLoadBalancerAttributeReconciler) Reconcile(ctx context.Context, r.logger.Info("modifying loadBalancer attributes", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), "change", attributesToUpdate) if _, err := r.elbv2Client.ModifyLoadBalancerAttributesWithContext(ctx, req); err != nil { return err @@ -64,7 +65,7 @@ func (r *defaultLoadBalancerAttributeReconciler) Reconcile(ctx context.Context, r.logger.Info("modified loadBalancer attributes", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn)) + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn)) } return nil } @@ -88,7 +89,7 @@ func (r *defaultLoadBalancerAttributeReconciler) getCurrentLoadBalancerAttribute lbAttributes := make(map[string]string, len(resp.Attributes)) for _, attr := range resp.Attributes { - lbAttributes[awssdk.StringValue(attr.Key)] = awssdk.StringValue(attr.Value) + lbAttributes[awssdk.ToString(attr.Key)] = awssdk.ToString(attr.Value) } return lbAttributes, nil } diff --git a/pkg/deploy/elbv2/load_balancer_attributes_reconciler_test.go b/pkg/deploy/elbv2/load_balancer_attributes_reconciler_test.go index 662b31a649..be52e89999 100644 --- a/pkg/deploy/elbv2/load_balancer_attributes_reconciler_test.go +++ b/pkg/deploy/elbv2/load_balancer_attributes_reconciler_test.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -54,7 +55,7 @@ func Test_defaultLoadBalancerAttributeReconciler_updateSDKLoadBalancerWithAttrib LoadBalancerArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeLoadBalancerAttributesOutput{ - Attributes: []*elbv2sdk.LoadBalancerAttribute{ + Attributes: []elbv2types.LoadBalancerAttribute{ { Key: awssdk.String("idle_timeout.timeout_seconds"), Value: awssdk.String("50"), @@ -71,7 +72,7 @@ func Test_defaultLoadBalancerAttributeReconciler_updateSDKLoadBalancerWithAttrib { req: &elbv2sdk.ModifyLoadBalancerAttributesInput{ LoadBalancerArn: awssdk.String("my-arn"), - Attributes: []*elbv2sdk.LoadBalancerAttribute{ + Attributes: []elbv2types.LoadBalancerAttribute{ { Key: awssdk.String("idle_timeout.timeout_seconds"), Value: awssdk.String("100"), @@ -87,7 +88,7 @@ func Test_defaultLoadBalancerAttributeReconciler_updateSDKLoadBalancerWithAttrib }, args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("my-arn"), }, }, @@ -117,7 +118,7 @@ func Test_defaultLoadBalancerAttributeReconciler_updateSDKLoadBalancerWithAttrib LoadBalancerArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeLoadBalancerAttributesOutput{ - Attributes: []*elbv2sdk.LoadBalancerAttribute{ + Attributes: []elbv2types.LoadBalancerAttribute{ { Key: awssdk.String("idle_timeout.timeout_seconds"), Value: awssdk.String("50"), @@ -134,7 +135,7 @@ func Test_defaultLoadBalancerAttributeReconciler_updateSDKLoadBalancerWithAttrib }, args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("my-arn"), }, }, @@ -258,7 +259,7 @@ func Test_defaultLoadBalancerAttributeReconciler_getCurrentLoadBalancerAttribute LoadBalancerArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeLoadBalancerAttributesOutput{ - Attributes: []*elbv2sdk.LoadBalancerAttribute{ + Attributes: []elbv2types.LoadBalancerAttribute{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -274,7 +275,7 @@ func Test_defaultLoadBalancerAttributeReconciler_getCurrentLoadBalancerAttribute }, args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("my-arn"), }, Tags: nil, @@ -299,7 +300,7 @@ func Test_defaultLoadBalancerAttributeReconciler_getCurrentLoadBalancerAttribute }, args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("my-arn"), }, Tags: nil, diff --git a/pkg/deploy/elbv2/load_balancer_manager.go b/pkg/deploy/elbv2/load_balancer_manager.go index ee4bfc30af..a7ecc4ef25 100644 --- a/pkg/deploy/elbv2/load_balancer_manager.go +++ b/pkg/deploy/elbv2/load_balancer_manager.go @@ -3,9 +3,9 @@ package elbv2 import ( "context" "fmt" - - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -65,13 +65,13 @@ func (m *defaultLoadBalancerManager) Create(ctx context.Context, resLB *elbv2mod return elbv2model.LoadBalancerStatus{}, err } sdkLB := LoadBalancerWithTags{ - LoadBalancer: resp.LoadBalancers[0], + LoadBalancer: &resp.LoadBalancers[0], Tags: lbTags, } m.logger.Info("created loadBalancer", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn)) + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn)) if err := m.attributesReconciler.Reconcile(ctx, resLB, sdkLB); err != nil { return elbv2model.LoadBalancerStatus{}, err } @@ -112,34 +112,34 @@ func (m *defaultLoadBalancerManager) Delete(ctx context.Context, sdkLB LoadBalan LoadBalancerArn: sdkLB.LoadBalancer.LoadBalancerArn, } m.logger.Info("deleting loadBalancer", - "arn", awssdk.StringValue(req.LoadBalancerArn)) + "arn", awssdk.ToString(req.LoadBalancerArn)) if _, err := m.elbv2Client.DeleteLoadBalancerWithContext(ctx, req); err != nil { return err } m.logger.Info("deleted loadBalancer", - "arn", awssdk.StringValue(req.LoadBalancerArn)) + "arn", awssdk.ToString(req.LoadBalancerArn)) return nil } func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithIPAddressType(ctx context.Context, resLB *elbv2model.LoadBalancer, sdkLB LoadBalancerWithTags) error { - if resLB.Spec.IPAddressType == nil { + if &resLB.Spec.IPAddressType == nil { return nil } - desiredIPAddressType := string(*resLB.Spec.IPAddressType) - currentIPAddressType := awssdk.StringValue(sdkLB.LoadBalancer.IpAddressType) - if desiredIPAddressType == currentIPAddressType { + desiredIPAddressType := string(resLB.Spec.IPAddressType) + currentIPAddressType := sdkLB.LoadBalancer.IpAddressType + if desiredIPAddressType == string(currentIPAddressType) { return nil } req := &elbv2sdk.SetIpAddressTypeInput{ LoadBalancerArn: sdkLB.LoadBalancer.LoadBalancerArn, - IpAddressType: awssdk.String(desiredIPAddressType), + IpAddressType: elbv2types.IpAddressType(desiredIPAddressType), } changeDesc := fmt.Sprintf("%v => %v", currentIPAddressType, desiredIPAddressType) m.logger.Info("modifying loadBalancer ipAddressType", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), "change", changeDesc) if _, err := m.elbv2Client.SetIpAddressTypeWithContext(ctx, req); err != nil { return err @@ -147,7 +147,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithIPAddressType(ctx m.logger.Info("modified loadBalancer ipAddressType", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn)) + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn)) return nil } @@ -159,7 +159,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSubnetMappings(ctx } currentSubnets := sets.NewString() for _, az := range sdkLB.LoadBalancer.AvailabilityZones { - currentSubnets.Insert(awssdk.StringValue(az.SubnetId)) + currentSubnets.Insert(awssdk.ToString(az.SubnetId)) } if desiredSubnets.Equal(currentSubnets) { return nil @@ -173,7 +173,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSubnetMappings(ctx m.logger.Info("modifying loadBalancer subnetMappings", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), "change", changeDesc) if _, err := m.elbv2Client.SetSubnetsWithContext(ctx, req); err != nil { return err @@ -181,7 +181,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSubnetMappings(ctx m.logger.Info("modified loadBalancer subnetMappings", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn)) + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn)) return nil } @@ -191,8 +191,8 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSecurityGroups(ctx if err != nil { return err } - desiredSecurityGroups := sets.NewString(awssdk.StringValueSlice(securityGroups)...) - currentSecurityGroups := sets.NewString(awssdk.StringValueSlice(sdkLB.LoadBalancer.SecurityGroups)...) + desiredSecurityGroups := sets.NewString(securityGroups...) + currentSecurityGroups := sets.NewString(sdkLB.LoadBalancer.SecurityGroups...) isEnforceSGInboundRulesOnPrivateLinkUpdated, currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic, desiredEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic := isEnforceSGInboundRulesOnPrivateLinkUpdated(resLB, sdkLB) if desiredSecurityGroups.Equal(currentSecurityGroups) && !isEnforceSGInboundRulesOnPrivateLinkUpdated { @@ -214,7 +214,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSecurityGroups(ctx if isEnforceSGInboundRulesOnPrivateLinkUpdated { changeEnforceSecurityGroupInboundRulesOnPrivateLinkTrafficDesc := fmt.Sprintf("%v => %v", currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic, desiredEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic) changeDescriptions = append(changeDescriptions, "changeEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic", changeEnforceSecurityGroupInboundRulesOnPrivateLinkTrafficDesc) - req.EnforceSecurityGroupInboundRulesOnPrivateLinkTraffic = &desiredEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic + req.EnforceSecurityGroupInboundRulesOnPrivateLinkTraffic = elbv2types.EnforceSecurityGroupInboundRulesOnPrivateLinkTrafficEnum(desiredEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic) } if _, err := m.elbv2Client.SetSecurityGroupsWithContext(ctx, req); err != nil { @@ -223,7 +223,7 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSecurityGroups(ctx m.logger.Info("modified loadBalancer securityGroups", "stackID", resLB.Stack().StackID(), "resourceID", resLB.ID(), - "arn", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), + "arn", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), "changeSecurityGroups", changeDescriptions, ) @@ -231,17 +231,17 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithSecurityGroups(ctx } func (m *defaultLoadBalancerManager) checkSDKLoadBalancerWithCOIPv4Pool(_ context.Context, resLB *elbv2model.LoadBalancer, sdkLB LoadBalancerWithTags) error { - if awssdk.StringValue(resLB.Spec.CustomerOwnedIPv4Pool) != awssdk.StringValue(sdkLB.LoadBalancer.CustomerOwnedIpv4Pool) { + if awssdk.ToString(resLB.Spec.CustomerOwnedIPv4Pool) != awssdk.ToString(sdkLB.LoadBalancer.CustomerOwnedIpv4Pool) { m.logger.Info("loadBalancer has drifted CustomerOwnedIPv4Pool setting", - "desired", awssdk.StringValue(resLB.Spec.CustomerOwnedIPv4Pool), - "current", awssdk.StringValue(sdkLB.LoadBalancer.CustomerOwnedIpv4Pool)) + "desired", awssdk.ToString(resLB.Spec.CustomerOwnedIPv4Pool), + "current", awssdk.ToString(sdkLB.LoadBalancer.CustomerOwnedIpv4Pool)) } return nil } func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithTags(ctx context.Context, resLB *elbv2model.LoadBalancer, sdkLB LoadBalancerWithTags) error { desiredLBTags := m.trackingProvider.ResourceTags(resLB.Stack(), resLB, resLB.Spec.Tags) - return m.taggingManager.ReconcileTags(ctx, awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), desiredLBTags, + return m.taggingManager.ReconcileTags(ctx, awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), desiredLBTags, WithCurrentTags(sdkLB.Tags), WithIgnoredTagKeys(m.trackingProvider.LegacyTagKeys()), WithIgnoredTagKeys(m.externalManagedTags)) @@ -250,19 +250,9 @@ func (m *defaultLoadBalancerManager) updateSDKLoadBalancerWithTags(ctx context.C func buildSDKCreateLoadBalancerInput(lbSpec elbv2model.LoadBalancerSpec) (*elbv2sdk.CreateLoadBalancerInput, error) { sdkObj := &elbv2sdk.CreateLoadBalancerInput{} sdkObj.Name = awssdk.String(lbSpec.Name) - sdkObj.Type = awssdk.String(string(lbSpec.Type)) - - if lbSpec.Scheme != nil { - sdkObj.Scheme = (*string)(lbSpec.Scheme) - } else { - sdkObj.Scheme = nil - } - - if lbSpec.IPAddressType != nil { - sdkObj.IpAddressType = (*string)(lbSpec.IPAddressType) - } else { - sdkObj.IpAddressType = nil - } + sdkObj.Type = elbv2types.LoadBalancerTypeEnum(lbSpec.Type) + sdkObj.Scheme = elbv2types.LoadBalancerSchemeEnum(lbSpec.Scheme) + sdkObj.IpAddressType = elbv2types.IpAddressType(lbSpec.IPAddressType) sdkObj.SubnetMappings = buildSDKSubnetMappings(lbSpec.SubnetMappings) if sdkSecurityGroups, err := buildSDKSecurityGroups(lbSpec.SecurityGroups); err != nil { @@ -275,10 +265,10 @@ func buildSDKCreateLoadBalancerInput(lbSpec elbv2model.LoadBalancerSpec) (*elbv2 return sdkObj, nil } -func buildSDKSubnetMappings(modelSubnetMappings []elbv2model.SubnetMapping) []*elbv2sdk.SubnetMapping { - var sdkSubnetMappings []*elbv2sdk.SubnetMapping +func buildSDKSubnetMappings(modelSubnetMappings []elbv2model.SubnetMapping) []elbv2types.SubnetMapping { + var sdkSubnetMappings []elbv2types.SubnetMapping if len(modelSubnetMappings) != 0 { - sdkSubnetMappings = make([]*elbv2sdk.SubnetMapping, 0, len(modelSubnetMappings)) + sdkSubnetMappings = make([]elbv2types.SubnetMapping, 0, len(modelSubnetMappings)) for _, modelSubnetMapping := range modelSubnetMappings { sdkSubnetMappings = append(sdkSubnetMappings, buildSDKSubnetMapping(modelSubnetMapping)) } @@ -286,24 +276,24 @@ func buildSDKSubnetMappings(modelSubnetMappings []elbv2model.SubnetMapping) []*e return sdkSubnetMappings } -func buildSDKSecurityGroups(modelSecurityGroups []coremodel.StringToken) ([]*string, error) { +func buildSDKSecurityGroups(modelSecurityGroups []coremodel.StringToken) ([]string, error) { ctx := context.Background() - var sdkSecurityGroups []*string + var sdkSecurityGroups []string if len(modelSecurityGroups) != 0 { - sdkSecurityGroups = make([]*string, 0, len(modelSecurityGroups)) + sdkSecurityGroups = make([]string, 0, len(modelSecurityGroups)) for _, modelSecurityGroup := range modelSecurityGroups { token, err := modelSecurityGroup.Resolve(ctx) if err != nil { return nil, err } - sdkSecurityGroups = append(sdkSecurityGroups, awssdk.String(token)) + sdkSecurityGroups = append(sdkSecurityGroups, token) } } return sdkSecurityGroups, nil } -func buildSDKSubnetMapping(modelSubnetMapping elbv2model.SubnetMapping) *elbv2sdk.SubnetMapping { - return &elbv2sdk.SubnetMapping{ +func buildSDKSubnetMapping(modelSubnetMapping elbv2model.SubnetMapping) elbv2types.SubnetMapping { + return elbv2types.SubnetMapping{ AllocationId: modelSubnetMapping.AllocationID, PrivateIPv4Address: modelSubnetMapping.PrivateIPv4Address, IPv6Address: modelSubnetMapping.IPv6Address, @@ -313,8 +303,8 @@ func buildSDKSubnetMapping(modelSubnetMapping elbv2model.SubnetMapping) *elbv2sd func buildResLoadBalancerStatus(sdkLB LoadBalancerWithTags) elbv2model.LoadBalancerStatus { return elbv2model.LoadBalancerStatus{ - LoadBalancerARN: awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn), - DNSName: awssdk.StringValue(sdkLB.LoadBalancer.DNSName), + LoadBalancerARN: awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn), + DNSName: awssdk.ToString(sdkLB.LoadBalancer.DNSName), } } @@ -329,7 +319,7 @@ func isEnforceSGInboundRulesOnPrivateLinkUpdated(resLB *elbv2model.LoadBalancer, var currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic string if sdkLB.LoadBalancer.EnforceSecurityGroupInboundRulesOnPrivateLinkTraffic != nil { - currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic = awssdk.StringValue(sdkLB.LoadBalancer.EnforceSecurityGroupInboundRulesOnPrivateLinkTraffic) + currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic = awssdk.ToString(sdkLB.LoadBalancer.EnforceSecurityGroupInboundRulesOnPrivateLinkTraffic) } if desiredEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic == currentEnforceSecurityGroupInboundRulesOnPrivateLinkTraffic { diff --git a/pkg/deploy/elbv2/load_balancer_manager_test.go b/pkg/deploy/elbv2/load_balancer_manager_test.go index 186281490d..8014c6149c 100644 --- a/pkg/deploy/elbv2/load_balancer_manager_test.go +++ b/pkg/deploy/elbv2/load_balancer_manager_test.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/stretchr/testify/assert" coremodel "sigs.k8s.io/aws-load-balancer-controller/pkg/model/core" @@ -31,8 +32,8 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { lbSpec: elbv2model.LoadBalancerSpec{ Name: "my-alb", Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemeInternetFacing, - IPAddressType: &addressTypeDualStack, + Scheme: schemeInternetFacing, + IPAddressType: addressTypeDualStack, SubnetMappings: []elbv2model.SubnetMapping{ { SubnetID: "subnet-A", @@ -49,10 +50,10 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { }, want: &elbv2sdk.CreateLoadBalancerInput{ Name: awssdk.String("my-alb"), - Type: awssdk.String("application"), - IpAddressType: awssdk.String("dualstack"), - Scheme: awssdk.String("internet-facing"), - SubnetMappings: []*elbv2sdk.SubnetMapping{ + Type: elbv2types.LoadBalancerTypeEnumApplication, + IpAddressType: elbv2types.IpAddressTypeDualstack, + Scheme: elbv2types.LoadBalancerSchemeEnumInternetFacing, + SubnetMappings: []elbv2types.SubnetMapping{ { SubnetId: awssdk.String("subnet-A"), }, @@ -60,7 +61,7 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { SubnetId: awssdk.String("subnet-B"), }, }, - SecurityGroups: awssdk.StringSlice([]string{"sg-A", "sg-B"}), + SecurityGroups: []string{"sg-A", "sg-B"}, }, }, { @@ -69,8 +70,8 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { lbSpec: elbv2model.LoadBalancerSpec{ Name: "my-nlb", Type: elbv2model.LoadBalancerTypeNetwork, - Scheme: &schemeInternetFacing, - IPAddressType: &addressTypeDualStack, + Scheme: schemeInternetFacing, + IPAddressType: addressTypeDualStack, SubnetMappings: []elbv2model.SubnetMapping{ { SubnetID: "subnet-A", @@ -83,10 +84,10 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { }, want: &elbv2sdk.CreateLoadBalancerInput{ Name: awssdk.String("my-nlb"), - Type: awssdk.String("network"), - IpAddressType: awssdk.String("dualstack"), - Scheme: awssdk.String("internet-facing"), - SubnetMappings: []*elbv2sdk.SubnetMapping{ + Type: elbv2types.LoadBalancerTypeEnumNetwork, + IpAddressType: elbv2types.IpAddressTypeDualstack, + Scheme: elbv2types.LoadBalancerSchemeEnumInternetFacing, + SubnetMappings: []elbv2types.SubnetMapping{ { SubnetId: awssdk.String("subnet-A"), }, @@ -102,8 +103,8 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { lbSpec: elbv2model.LoadBalancerSpec{ Name: "my-alb", Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemeInternetFacing, - IPAddressType: &addressTypeDualStack, + Scheme: schemeInternetFacing, + IPAddressType: addressTypeDualStack, SubnetMappings: []elbv2model.SubnetMapping{ { SubnetID: "subnet-A", @@ -121,10 +122,10 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { }, want: &elbv2sdk.CreateLoadBalancerInput{ Name: awssdk.String("my-alb"), - Type: awssdk.String("application"), - IpAddressType: awssdk.String("dualstack"), - Scheme: awssdk.String("internet-facing"), - SubnetMappings: []*elbv2sdk.SubnetMapping{ + Type: elbv2types.LoadBalancerTypeEnumApplication, + IpAddressType: elbv2types.IpAddressTypeDualstack, + Scheme: elbv2types.LoadBalancerSchemeEnumInternetFacing, + SubnetMappings: []elbv2types.SubnetMapping{ { SubnetId: awssdk.String("subnet-A"), }, @@ -132,7 +133,7 @@ func Test_buildSDKCreateLoadBalancerInput(t *testing.T) { SubnetId: awssdk.String("subnet-B"), }, }, - SecurityGroups: awssdk.StringSlice([]string{"sg-A", "sg-B"}), + SecurityGroups: []string{"sg-A", "sg-B"}, CustomerOwnedIpv4Pool: awssdk.String("coIP-pool-x"), }, }, @@ -157,7 +158,7 @@ func Test_buildSDKSubnetMappings(t *testing.T) { tests := []struct { name string args args - want []*elbv2sdk.SubnetMapping + want []elbv2types.SubnetMapping }{ { name: "standard case", @@ -171,7 +172,7 @@ func Test_buildSDKSubnetMappings(t *testing.T) { }, }, }, - want: []*elbv2sdk.SubnetMapping{ + want: []elbv2types.SubnetMapping{ { SubnetId: awssdk.String("subnet-a"), }, @@ -196,7 +197,7 @@ func Test_buildSDKSecurityGroups(t *testing.T) { tests := []struct { name string args args - want []*string + want []string wantErr error }{ { @@ -206,7 +207,7 @@ func Test_buildSDKSecurityGroups(t *testing.T) { coremodel.LiteralStringToken("sg-a"), }, }, - want: awssdk.StringSlice([]string{"sg-a"}), + want: []string{"sg-a"}, }, { name: "multiple securityGroups", @@ -216,7 +217,7 @@ func Test_buildSDKSecurityGroups(t *testing.T) { coremodel.LiteralStringToken("sg-b"), }, }, - want: awssdk.StringSlice([]string{"sg-a", "sg-b"}), + want: []string{"sg-a", "sg-b"}, }, } for _, tt := range tests { @@ -239,7 +240,7 @@ func Test_buildSDKSubnetMapping(t *testing.T) { tests := []struct { name string args args - want *elbv2sdk.SubnetMapping + want elbv2types.SubnetMapping }{ { name: "stand case", @@ -250,7 +251,7 @@ func Test_buildSDKSubnetMapping(t *testing.T) { SubnetID: "subnet-abc", }, }, - want: &elbv2sdk.SubnetMapping{ + want: elbv2types.SubnetMapping{ AllocationId: awssdk.String("some-id"), PrivateIPv4Address: awssdk.String("192.168.100.0"), SubnetId: awssdk.String("subnet-abc"), @@ -263,7 +264,7 @@ func Test_buildSDKSubnetMapping(t *testing.T) { SubnetID: "subnet-abc", }, }, - want: &elbv2sdk.SubnetMapping{ + want: elbv2types.SubnetMapping{ SubnetId: awssdk.String("subnet-abc"), }, }, @@ -289,7 +290,7 @@ func Test_buildResLoadBalancerStatus(t *testing.T) { name: "standard case", args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("my-arn"), DNSName: awssdk.String("www.example.com"), }, @@ -328,7 +329,7 @@ func Test_defaultLoadBalancerManager_checkSDKLoadBalancerWithCOIPv4Pool(t *testi }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ CustomerOwnedIpv4Pool: nil, }, }, @@ -344,7 +345,7 @@ func Test_defaultLoadBalancerManager_checkSDKLoadBalancerWithCOIPv4Pool(t *testi }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ CustomerOwnedIpv4Pool: awssdk.String("ipv4pool-coip-abc"), }, }, @@ -360,7 +361,7 @@ func Test_defaultLoadBalancerManager_checkSDKLoadBalancerWithCOIPv4Pool(t *testi }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ CustomerOwnedIpv4Pool: awssdk.String("ipv4pool-coip-def"), }, }, @@ -376,7 +377,7 @@ func Test_defaultLoadBalancerManager_checkSDKLoadBalancerWithCOIPv4Pool(t *testi }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ CustomerOwnedIpv4Pool: nil, }, }, @@ -392,7 +393,7 @@ func Test_defaultLoadBalancerManager_checkSDKLoadBalancerWithCOIPv4Pool(t *testi }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ CustomerOwnedIpv4Pool: awssdk.String("ipv4pool-coip-abc"), }, }, diff --git a/pkg/deploy/elbv2/load_balancer_synthesizer.go b/pkg/deploy/elbv2/load_balancer_synthesizer.go index 46f96a698f..5758820476 100644 --- a/pkg/deploy/elbv2/load_balancer_synthesizer.go +++ b/pkg/deploy/elbv2/load_balancer_synthesizer.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/sets" @@ -64,7 +65,7 @@ func (s *loadBalancerSynthesizer) Synthesize(ctx context.Context) error { if err := s.lbManager.Delete(ctx, sdkLB); err != nil { errMessage := err.Error() if strings.Contains(errMessage, "OperationNotPermitted") && strings.Contains(errMessage, "deletion protection") { - s.disableDeletionProtection(sdkLB.LoadBalancer) + s.disableDeletionProtection(ctx, sdkLB.LoadBalancer) if err = s.lbManager.Delete(ctx, sdkLB); err != nil { return err } @@ -90,9 +91,9 @@ func (s *loadBalancerSynthesizer) Synthesize(ctx context.Context) error { return nil } -func (s *loadBalancerSynthesizer) disableDeletionProtection(lb *elbv2sdk.LoadBalancer) error { +func (s *loadBalancerSynthesizer) disableDeletionProtection(ctx context.Context, lb *elbv2types.LoadBalancer) error { input := &elbv2sdk.ModifyLoadBalancerAttributesInput{ - Attributes: []*elbv2sdk.LoadBalancerAttribute{ + Attributes: []elbv2types.LoadBalancerAttribute{ { Key: awssdk.String(lbAttrsDeletionProtectionEnabled), Value: awssdk.String("false"), @@ -100,7 +101,7 @@ func (s *loadBalancerSynthesizer) disableDeletionProtection(lb *elbv2sdk.LoadBal }, LoadBalancerArn: lb.LoadBalancerArn, } - _, err := s.elbv2Client.ModifyLoadBalancerAttributes(input) + _, err := s.elbv2Client.ModifyLoadBalancerAttributesWithContext(ctx, input) return err } @@ -179,7 +180,7 @@ func mapSDKLoadBalancerByResourceID(sdkLBs []LoadBalancerWithTags, resourceIDTag for _, sdkLB := range sdkLBs { resourceID, ok := sdkLB.Tags[resourceIDTagKey] if !ok { - return nil, errors.Errorf("unexpected loadBalancer with no resourceID: %v", awssdk.StringValue(sdkLB.LoadBalancer.LoadBalancerArn)) + return nil, errors.Errorf("unexpected loadBalancer with no resourceID: %v", awssdk.ToString(sdkLB.LoadBalancer.LoadBalancerArn)) } sdkLBsByID[resourceID] = append(sdkLBsByID[resourceID], sdkLB) } @@ -188,10 +189,10 @@ func mapSDKLoadBalancerByResourceID(sdkLBs []LoadBalancerWithTags, resourceIDTag // isSDKLoadBalancerRequiresReplacement checks whether a sdk LoadBalancer requires replacement to fulfill a LoadBalancer resource. func isSDKLoadBalancerRequiresReplacement(sdkLB LoadBalancerWithTags, resLB *elbv2model.LoadBalancer) bool { - if string(resLB.Spec.Type) != awssdk.StringValue(sdkLB.LoadBalancer.Type) { + if string(resLB.Spec.Type) != string(sdkLB.LoadBalancer.Type) { return true } - if resLB.Spec.Scheme != nil && string(*resLB.Spec.Scheme) != awssdk.StringValue(sdkLB.LoadBalancer.Scheme) { + if &resLB.Spec.Scheme != nil && string(resLB.Spec.Scheme) != string(sdkLB.LoadBalancer.Scheme) { return true } return false diff --git a/pkg/deploy/elbv2/load_balancer_synthesizer_test.go b/pkg/deploy/elbv2/load_balancer_synthesizer_test.go index 6f475324be..50940fd7b9 100644 --- a/pkg/deploy/elbv2/load_balancer_synthesizer_test.go +++ b/pkg/deploy/elbv2/load_balancer_synthesizer_test.go @@ -1,10 +1,10 @@ package elbv2 import ( + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" "github.com/stretchr/testify/assert" coremodel "sigs.k8s.io/aws-load-balancer-controller/pkg/model/core" @@ -45,7 +45,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -53,7 +53,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -72,7 +72,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -88,7 +88,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -117,7 +117,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -136,7 +136,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -167,7 +167,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -175,7 +175,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -194,7 +194,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -205,7 +205,7 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, want2: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -228,18 +228,18 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), - Type: awssdk.String("application"), + Type: elbv2types.LoadBalancerTypeEnum("application"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), - Type: awssdk.String("network"), + Type: elbv2types.LoadBalancerTypeEnum("network"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -258,9 +258,9 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, }, sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), - Type: awssdk.String("network"), + Type: elbv2types.LoadBalancerTypeEnum("network"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -270,9 +270,9 @@ func Test_matchResAndSDKLoadBalancers(t *testing.T) { }, want2: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), - Type: awssdk.String("application"), + Type: elbv2types.LoadBalancerTypeEnum("application"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -364,7 +364,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { args: args{ sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -372,7 +372,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -385,7 +385,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { want: map[string][]LoadBalancerWithTags{ "id-1": { { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -395,7 +395,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, "id-2": { { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -410,7 +410,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { args: args{ sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -418,7 +418,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2A"), }, Tags: map[string]string{ @@ -426,7 +426,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2B"), }, Tags: map[string]string{ @@ -439,7 +439,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { want: map[string][]LoadBalancerWithTags{ "id-1": { { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -449,7 +449,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, "id-2": { { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2A"), }, Tags: map[string]string{ @@ -457,7 +457,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-2B"), }, Tags: map[string]string{ @@ -472,7 +472,7 @@ func Test_mapSDKLoadBalancerByResourceID(t *testing.T) { args: args{ sdkLBs: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("arn-1"), }, Tags: map[string]string{}, @@ -511,16 +511,16 @@ func Test_isSDKLoadBalancerRequiresReplacement(t *testing.T) { name: "don't need replacement", args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ - Type: awssdk.String("application"), - Scheme: awssdk.String("internet-facing"), + LoadBalancer: &elbv2types.LoadBalancer{ + Type: elbv2types.LoadBalancerTypeEnum("application"), + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), LoadBalancerName: awssdk.String("my-lb"), }, }, resLB: &elbv2model.LoadBalancer{ Spec: elbv2model.LoadBalancerSpec{ Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemaInternetFacing, + Scheme: schemaInternetFacing, Name: "my-lb", }, }, @@ -531,16 +531,16 @@ func Test_isSDKLoadBalancerRequiresReplacement(t *testing.T) { name: "name-only change shouldn't need replacement", args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ - Type: awssdk.String("application"), - Scheme: awssdk.String("internet-facing"), + LoadBalancer: &elbv2types.LoadBalancer{ + Type: elbv2types.LoadBalancerTypeEnum("application"), + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), LoadBalancerName: awssdk.String("my-lb1"), }, }, resLB: &elbv2model.LoadBalancer{ Spec: elbv2model.LoadBalancerSpec{ Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemaInternetFacing, + Scheme: schemaInternetFacing, Name: "my-lb", }, }, @@ -551,16 +551,16 @@ func Test_isSDKLoadBalancerRequiresReplacement(t *testing.T) { name: "type change need replacement", args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ - Type: awssdk.String("network"), - Scheme: awssdk.String("internet-facing"), + LoadBalancer: &elbv2types.LoadBalancer{ + Type: elbv2types.LoadBalancerTypeEnum("network"), + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), LoadBalancerName: awssdk.String("my-lb"), }, }, resLB: &elbv2model.LoadBalancer{ Spec: elbv2model.LoadBalancerSpec{ Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemaInternetFacing, + Scheme: schemaInternetFacing, Name: "my-lb", }, }, @@ -571,16 +571,16 @@ func Test_isSDKLoadBalancerRequiresReplacement(t *testing.T) { name: "scheme change need replacement", args: args{ sdkLB: LoadBalancerWithTags{ - LoadBalancer: &elbv2sdk.LoadBalancer{ - Type: awssdk.String("application"), - Scheme: awssdk.String("internal"), + LoadBalancer: &elbv2types.LoadBalancer{ + Type: elbv2types.LoadBalancerTypeEnumApplication, + Scheme: elbv2types.LoadBalancerSchemeEnumInternal, LoadBalancerName: awssdk.String("my-lb"), }, }, resLB: &elbv2model.LoadBalancer{ Spec: elbv2model.LoadBalancerSpec{ Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &schemaInternetFacing, + Scheme: schemaInternetFacing, Name: "my-lb", }, }, diff --git a/pkg/deploy/elbv2/tagging_manager.go b/pkg/deploy/elbv2/tagging_manager.go index 33caef61ef..efbadb568d 100644 --- a/pkg/deploy/elbv2/tagging_manager.go +++ b/pkg/deploy/elbv2/tagging_manager.go @@ -2,14 +2,16 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "sync" "time" "k8s.io/apimachinery/pkg/util/cache" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" - "github.com/aws/aws-sdk-go/service/resourcegroupstaggingapi" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + rgtsdk "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi" + rgttypes "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi/types" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/sets" @@ -28,25 +30,25 @@ const ( // LoadBalancer with it's tags. type LoadBalancerWithTags struct { - LoadBalancer *elbv2sdk.LoadBalancer + LoadBalancer *elbv2types.LoadBalancer Tags map[string]string } // TargetGroup with it's tags. type TargetGroupWithTags struct { - TargetGroup *elbv2sdk.TargetGroup + TargetGroup *elbv2types.TargetGroup Tags map[string]string } // Listener with it's tags. type ListenerWithTags struct { - Listener *elbv2sdk.Listener + Listener *elbv2types.Listener Tags map[string]string } // ListenerRule with tags type ListenerRuleWithTags struct { - ListenerRule *elbv2sdk.Rule + ListenerRule *elbv2types.Rule Tags map[string]string } @@ -155,7 +157,7 @@ func (m *defaultTaggingManager) ReconcileTags(ctx context.Context, arn string, d if len(tagsToUpdate) > 0 { req := &elbv2sdk.AddTagsInput{ - ResourceArns: []*string{awssdk.String(arn)}, + ResourceArns: []string{arn}, Tags: convertTagsToSDKTags(tagsToUpdate), } @@ -173,8 +175,8 @@ func (m *defaultTaggingManager) ReconcileTags(ctx context.Context, arn string, d if len(tagsToRemove) > 0 { tagKeys := sets.StringKeySet(tagsToRemove).List() req := &elbv2sdk.RemoveTagsInput{ - ResourceArns: []*string{awssdk.String(arn)}, - TagKeys: awssdk.StringSlice(tagKeys), + ResourceArns: []string{arn}, + TagKeys: tagKeys, } m.logger.Info("removing resource tags", @@ -199,11 +201,11 @@ func (m *defaultTaggingManager) ListListeners(ctx context.Context, lbARN string) return nil, err } lsARNs := make([]string, 0, len(listeners)) - lsByARN := make(map[string]*elbv2sdk.Listener, len(listeners)) + lsByARN := make(map[string]*elbv2types.Listener, len(listeners)) for _, listener := range listeners { - lsARN := awssdk.StringValue(listener.ListenerArn) + lsARN := awssdk.ToString(listener.ListenerArn) lsARNs = append(lsARNs, lsARN) - lsByARN[lsARN] = listener + lsByARN[lsARN] = &listener } var tagsByARN map[string]map[string]string if m.featureGates.Enabled(config.ListenerRulesTagging) { @@ -232,11 +234,11 @@ func (m *defaultTaggingManager) ListListenerRules(ctx context.Context, lsARN str return nil, err } lrARNs := make([]string, 0, len(rules)) - lrByARN := make(map[string]*elbv2sdk.Rule, len(rules)) + lrByARN := make(map[string]*elbv2types.Rule, len(rules)) for _, rule := range rules { - lrARN := awssdk.StringValue(rule.RuleArn) + lrARN := awssdk.ToString(rule.RuleArn) lrARNs = append(lrARNs, lrARN) - lrByARN[lrARN] = rule + lrByARN[lrARN] = &rule } var tagsByARN map[string]map[string]string if m.featureGates.Enabled(config.ListenerRulesTagging) { @@ -275,26 +277,26 @@ func (m *defaultTaggingManager) ListTargetGroups(ctx context.Context, tagFilters func (m *defaultTaggingManager) listLoadBalancersRGT(ctx context.Context, tagFilters []tracking.TagFilter) ([]LoadBalancerWithTags, error) { // use a map to avoid potential duplication in returned resources - resourceTagsByARN := make(map[string][]*resourcegroupstaggingapi.Tag) + resourceTagsByARN := make(map[string][]rgttypes.Tag) for _, tagFilter := range tagFilters { - req := &resourcegroupstaggingapi.GetResourcesInput{ + req := &rgtsdk.GetResourcesInput{ TagFilters: convertTagFiltersToRGTTagFilters(tagFilter), - ResourceTypeFilters: awssdk.StringSlice([]string{services.ResourceTypeELBLoadBalancer}), + ResourceTypeFilters: []string{services.ResourceTypeELBLoadBalancer}, } resources, err := m.rgt.GetResourcesAsList(ctx, req) if err != nil { return nil, err } for _, resource := range resources { - if _, exists := resourceTagsByARN[awssdk.StringValue(resource.ResourceARN)]; !exists { - resourceTagsByARN[awssdk.StringValue(resource.ResourceARN)] = resource.Tags + if _, exists := resourceTagsByARN[awssdk.ToString(resource.ResourceARN)]; !exists { + resourceTagsByARN[awssdk.ToString(resource.ResourceARN)] = resource.Tags } } } var matchedLBs []LoadBalancerWithTags for resourceARN, resourceTags := range resourceTagsByARN { elbv2Req := &elbv2sdk.DescribeLoadBalancersInput{ - LoadBalancerArns: []*string{&resourceARN}, + LoadBalancerArns: []string{resourceARN}, } elbv2Resp, err := m.elbv2Client.DescribeLoadBalancersAsList(ctx, elbv2Req) if err != nil { @@ -304,7 +306,7 @@ func (m *defaultTaggingManager) listLoadBalancersRGT(ctx context.Context, tagFil return nil, errors.Errorf("no load balancer found for the arn: %v", resourceARN) } matchedLBs = append(matchedLBs, LoadBalancerWithTags{ - LoadBalancer: elbv2Resp[0], + LoadBalancer: &elbv2Resp[0], Tags: services.ParseRGTTags(resourceTags), }) } @@ -318,14 +320,14 @@ func (m *defaultTaggingManager) listLoadBalancersNative(ctx context.Context, tag return nil, err } lbARNsWithinVPC := make([]string, 0, len(lbs)) - lbByARNWithinVPC := make(map[string]*elbv2sdk.LoadBalancer, len(lbs)) + lbByARNWithinVPC := make(map[string]*elbv2types.LoadBalancer, len(lbs)) for _, lb := range lbs { - if awssdk.StringValue(lb.VpcId) != m.vpcID { + if awssdk.ToString(lb.VpcId) != m.vpcID { continue } - lbARN := awssdk.StringValue(lb.LoadBalancerArn) + lbARN := awssdk.ToString(lb.LoadBalancerArn) lbARNsWithinVPC = append(lbARNsWithinVPC, lbARN) - lbByARNWithinVPC[lbARN] = lb + lbByARNWithinVPC[lbARN] = &lb } tagsByARN, err := m.describeResourceTags(ctx, lbARNsWithinVPC) if err != nil { @@ -354,26 +356,26 @@ func (m *defaultTaggingManager) listLoadBalancersNative(ctx context.Context, tag func (m *defaultTaggingManager) listTargetGroupsRGT(ctx context.Context, tagFilters []tracking.TagFilter) ([]TargetGroupWithTags, error) { // use a map to avoid potential duplication in returned resources - resourceTagsByARN := make(map[string][]*resourcegroupstaggingapi.Tag) + resourceTagsByARN := make(map[string][]rgttypes.Tag) for _, tagFilter := range tagFilters { - req := &resourcegroupstaggingapi.GetResourcesInput{ + req := &rgtsdk.GetResourcesInput{ TagFilters: convertTagFiltersToRGTTagFilters(tagFilter), - ResourceTypeFilters: awssdk.StringSlice([]string{services.ResourceTypeELBTargetGroup}), + ResourceTypeFilters: []string{services.ResourceTypeELBTargetGroup}, } resources, err := m.rgt.GetResourcesAsList(ctx, req) if err != nil { return nil, err } for _, resource := range resources { - if _, exists := resourceTagsByARN[awssdk.StringValue(resource.ResourceARN)]; !exists { - resourceTagsByARN[awssdk.StringValue(resource.ResourceARN)] = resource.Tags + if _, exists := resourceTagsByARN[awssdk.ToString(resource.ResourceARN)]; !exists { + resourceTagsByARN[awssdk.ToString(resource.ResourceARN)] = resource.Tags } } } var matchedTGs []TargetGroupWithTags for resourceARN, resourceTags := range resourceTagsByARN { elbv2Req := &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: []*string{&resourceARN}, + TargetGroupArns: []string{resourceARN}, } elbv2Resp, err := m.elbv2Client.DescribeTargetGroupsAsList(ctx, elbv2Req) if err != nil { @@ -383,7 +385,7 @@ func (m *defaultTaggingManager) listTargetGroupsRGT(ctx context.Context, tagFilt return nil, errors.Errorf("no target group found for the arn: %v", resourceARN) } matchedTGs = append(matchedTGs, TargetGroupWithTags{ - TargetGroup: elbv2Resp[0], + TargetGroup: &elbv2Resp[0], Tags: services.ParseRGTTags(resourceTags), }) } @@ -398,14 +400,14 @@ func (m *defaultTaggingManager) listTargetGroupsNative(ctx context.Context, tagF } tgARNsWithinVPC := make([]string, 0, len(tgs)) - tgByARNWithinVPC := make(map[string]*elbv2sdk.TargetGroup, len(tgs)) + tgByARNWithinVPC := make(map[string]*elbv2types.TargetGroup, len(tgs)) for _, tg := range tgs { - if awssdk.StringValue(tg.VpcId) != m.vpcID { + if awssdk.ToString(tg.VpcId) != m.vpcID { continue } - tgARN := awssdk.StringValue(tg.TargetGroupArn) + tgARN := awssdk.ToString(tg.TargetGroupArn) tgARNsWithinVPC = append(tgARNsWithinVPC, tgARN) - tgByARNWithinVPC[tgARN] = tg + tgByARNWithinVPC[tgARN] = &tg } tagsByARN, err := m.describeResourceTags(ctx, tgARNsWithinVPC) if err != nil { @@ -464,14 +466,14 @@ func (m *defaultTaggingManager) describeResourceTagsFromAWS(ctx context.Context, arnsChunks := algorithm.ChunkStrings(arns, m.describeTagsChunkSize) for _, arnsChunk := range arnsChunks { req := &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice(arnsChunk), + ResourceArns: arnsChunk, } resp, err := m.elbv2Client.DescribeTagsWithContext(ctx, req) if err != nil { return nil, err } for _, tagDescription := range resp.TagDescriptions { - tagsByARN[awssdk.StringValue(tagDescription.ResourceArn)] = convertSDKTagsToTags(tagDescription.Tags) + tagsByARN[awssdk.ToString(tagDescription.ResourceArn)] = convertSDKTagsToTags(tagDescription.Tags) } } return tagsByARN, nil @@ -485,14 +487,14 @@ func (m *defaultTaggingManager) invalidateResourceTagsCache(arn string) { } // convert tags into AWS SDK tag presentation. -func convertTagsToSDKTags(tags map[string]string) []*elbv2sdk.Tag { +func convertTagsToSDKTags(tags map[string]string) []elbv2types.Tag { if len(tags) == 0 { return nil } - sdkTags := make([]*elbv2sdk.Tag, 0, len(tags)) + sdkTags := make([]elbv2types.Tag, 0, len(tags)) for _, key := range sets.StringKeySet(tags).List() { - sdkTags = append(sdkTags, &elbv2sdk.Tag{ + sdkTags = append(sdkTags, elbv2types.Tag{ Key: awssdk.String(key), Value: awssdk.String(tags[key]), }) @@ -501,21 +503,21 @@ func convertTagsToSDKTags(tags map[string]string) []*elbv2sdk.Tag { } // convert AWS SDK tag presentation into tags. -func convertSDKTagsToTags(sdkTags []*elbv2sdk.Tag) map[string]string { +func convertSDKTagsToTags(sdkTags []elbv2types.Tag) map[string]string { tags := make(map[string]string, len(sdkTags)) for _, sdkTag := range sdkTags { - tags[awssdk.StringValue(sdkTag.Key)] = awssdk.StringValue(sdkTag.Value) + tags[awssdk.ToString(sdkTag.Key)] = awssdk.ToString(sdkTag.Value) } return tags } // convert tagFilters to RGTTagFilters -func convertTagFiltersToRGTTagFilters(tagFilter tracking.TagFilter) []*resourcegroupstaggingapi.TagFilter { - var RGTTagFilters []*resourcegroupstaggingapi.TagFilter +func convertTagFiltersToRGTTagFilters(tagFilter tracking.TagFilter) []rgttypes.TagFilter { + var RGTTagFilters []rgttypes.TagFilter for k, v := range tagFilter { - RGTTagFilters = append(RGTTagFilters, &resourcegroupstaggingapi.TagFilter{ + RGTTagFilters = append(RGTTagFilters, rgttypes.TagFilter{ Key: awssdk.String(k), - Values: awssdk.StringSlice(v), + Values: v, }) } return RGTTagFilters diff --git a/pkg/deploy/elbv2/tagging_manager_test.go b/pkg/deploy/elbv2/tagging_manager_test.go index ec5c826505..0b6e7ad2e0 100644 --- a/pkg/deploy/elbv2/tagging_manager_test.go +++ b/pkg/deploy/elbv2/tagging_manager_test.go @@ -2,11 +2,12 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "k8s.io/apimachinery/pkg/util/cache" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" @@ -55,13 +56,13 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, + ResourceArns: []string{"my-arn"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("my-arn"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -83,8 +84,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { addTagsWithContextCalls: []addTagsWithContextCall{ { req: &elbv2sdk.AddTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - Tags: []*elbv2sdk.Tag{ + ResourceArns: []string{"my-arn"}, + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyB"), Value: awssdk.String("valueB2"), @@ -100,8 +101,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { removeTagsWithContextCalls: []removeTagsWithContextCall{ { req: &elbv2sdk.RemoveTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - TagKeys: []*string{awssdk.String("keyC")}, + ResourceArns: []string{"my-arn"}, + TagKeys: []string{"keyC"}, }, }, }, @@ -123,8 +124,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { addTagsWithContextCalls: []addTagsWithContextCall{ { req: &elbv2sdk.AddTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - Tags: []*elbv2sdk.Tag{ + ResourceArns: []string{"my-arn"}, + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyB"), Value: awssdk.String("valueB2"), @@ -140,8 +141,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { removeTagsWithContextCalls: []removeTagsWithContextCall{ { req: &elbv2sdk.RemoveTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - TagKeys: []*string{awssdk.String("keyC")}, + ResourceArns: []string{"my-arn"}, + TagKeys: []string{"keyC"}, }, }, }, @@ -169,8 +170,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { addTagsWithContextCalls: []addTagsWithContextCall{ { req: &elbv2sdk.AddTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - Tags: []*elbv2sdk.Tag{ + ResourceArns: []string{"my-arn"}, + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyC"), Value: awssdk.String("valueC2"), @@ -186,8 +187,8 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { removeTagsWithContextCalls: []removeTagsWithContextCall{ { req: &elbv2sdk.RemoveTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, - TagKeys: []*string{awssdk.String("keyF")}, + ResourceArns: []string{"my-arn"}, + TagKeys: []string{"keyF"}, }, }, }, @@ -251,7 +252,7 @@ func Test_defaultTaggingManager_ReconcileTags(t *testing.T) { func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { type describeLoadBalancersAsListCall struct { req *elbv2sdk.DescribeLoadBalancersInput - resp []*elbv2sdk.LoadBalancer + resp []elbv2types.LoadBalancer err error } type describeTagsWithContextCall struct { @@ -279,7 +280,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeLoadBalancersAsListCalls: []describeLoadBalancersAsListCall{ { req: &elbv2sdk.DescribeLoadBalancersInput{}, - resp: []*elbv2sdk.LoadBalancer{ + resp: []elbv2types.LoadBalancer{ { LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -298,13 +299,13 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"lb-1", "lb-2", "lb-3"}), + ResourceArns: []string{"lb-1", "lb-2", "lb-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("lb-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -317,7 +318,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, { ResourceArn: awssdk.String("lb-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -330,7 +331,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, { ResourceArn: awssdk.String("lb-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -355,14 +356,14 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, want: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, + LoadBalancer: &elbv2types.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA1", "keyB": "valueB1", }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{LoadBalancerArn: awssdk.String("lb-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, + LoadBalancer: &elbv2types.LoadBalancer{LoadBalancerArn: awssdk.String("lb-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA3", "keyB": "valueB3", @@ -376,7 +377,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeLoadBalancersAsListCalls: []describeLoadBalancersAsListCall{ { req: &elbv2sdk.DescribeLoadBalancersInput{}, - resp: []*elbv2sdk.LoadBalancer{ + resp: []elbv2types.LoadBalancer{ { LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -395,13 +396,13 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"lb-1", "lb-2"}), + ResourceArns: []string{"lb-1", "lb-2"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("lb-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -414,7 +415,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, { ResourceArn: awssdk.String("lb-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -439,7 +440,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, want: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, + LoadBalancer: &elbv2types.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA1", "keyB": "valueB1", @@ -453,7 +454,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeLoadBalancersAsListCalls: []describeLoadBalancersAsListCall{ { req: &elbv2sdk.DescribeLoadBalancersInput{}, - resp: []*elbv2sdk.LoadBalancer{ + resp: []elbv2types.LoadBalancer{ { LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -472,13 +473,13 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"lb-1"}), + ResourceArns: []string{"lb-1"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("lb-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -503,7 +504,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, want: []LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, + LoadBalancer: &elbv2types.LoadBalancer{LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA1", "keyB": "valueB1", @@ -517,7 +518,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeLoadBalancersAsListCalls: []describeLoadBalancersAsListCall{ { req: &elbv2sdk.DescribeLoadBalancersInput{}, - resp: []*elbv2sdk.LoadBalancer{ + resp: []elbv2types.LoadBalancer{ { LoadBalancerArn: awssdk.String("lb-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -536,13 +537,13 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"lb-1", "lb-2", "lb-3"}), + ResourceArns: []string{"lb-1", "lb-2", "lb-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("lb-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -555,7 +556,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, { ResourceArn: awssdk.String("lb-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -568,7 +569,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { }, { ResourceArn: awssdk.String("lb-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -629,7 +630,7 @@ func Test_defaultTaggingManager_ListLoadBalancers(t *testing.T) { func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } type describeTagsWithContextCall struct { @@ -657,7 +658,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{}, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -676,13 +677,13 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"tg-1", "tg-2", "tg-3"}), + ResourceArns: []string{"tg-1", "tg-2", "tg-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("tg-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -695,7 +696,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -708,7 +709,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -733,14 +734,14 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, want: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA1", "keyB": "valueB1", }, }, { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA3", "keyB": "valueB3", @@ -754,7 +755,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{}, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-yyyyyyy"), @@ -773,13 +774,13 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"tg-2", "tg-3"}), + ResourceArns: []string{"tg-2", "tg-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("tg-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -792,7 +793,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -817,7 +818,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, want: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA3", "keyB": "valueB3", @@ -831,7 +832,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{}, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-yyyyyyy"), @@ -850,13 +851,13 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"tg-3"}), + ResourceArns: []string{"tg-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("tg-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -881,7 +882,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, want: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-3"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA3", "keyB": "valueB3", @@ -895,7 +896,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{}, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -914,13 +915,13 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"tg-1", "tg-2", "tg-3"}), + ResourceArns: []string{"tg-1", "tg-2", "tg-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("tg-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -933,7 +934,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -946,7 +947,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -977,7 +978,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{}, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx"), @@ -1000,13 +1001,13 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"tg-1", "tg-2", "tg-3", "tg-4"}), + ResourceArns: []string{"tg-1", "tg-2", "tg-3", "tg-4"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("tg-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -1019,7 +1020,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -1032,7 +1033,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -1045,7 +1046,7 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, { ResourceArn: awssdk.String("tg-4"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA4"), @@ -1073,21 +1074,21 @@ func Test_defaultTaggingManager_ListTargetGroups(t *testing.T) { }, want: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-1"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA1", "keyB": "valueB1", }, }, { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-2"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-2"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA2", "keyB": "valueB2", }, }, { - TargetGroup: &elbv2sdk.TargetGroup{TargetGroupArn: awssdk.String("tg-4"), VpcId: awssdk.String("vpc-xxxxxxx")}, + TargetGroup: &elbv2types.TargetGroup{TargetGroupArn: awssdk.String("tg-4"), VpcId: awssdk.String("vpc-xxxxxxx")}, Tags: map[string]string{ "keyA": "valueA4", "keyB": "valueB4", @@ -1154,13 +1155,13 @@ func Test_defaultTaggingManager_describeResourceTags(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"arn-1", "arn-2", "arn-3"}), + ResourceArns: []string{"arn-1", "arn-2", "arn-3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("arn-1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -1173,7 +1174,7 @@ func Test_defaultTaggingManager_describeResourceTags(t *testing.T) { }, { ResourceArn: awssdk.String("arn-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -1186,7 +1187,7 @@ func Test_defaultTaggingManager_describeResourceTags(t *testing.T) { }, { ResourceArn: awssdk.String("arn-3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -1273,13 +1274,13 @@ func Test_defaultTaggingManager_describeResourceTags(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{"arn-2"}), + ResourceArns: []string{"arn-2"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("arn-2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -1370,13 +1371,13 @@ func Test_defaultTaggingManager_describeResourceTagsFromAWS(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn")}, + ResourceArns: []string{"my-arn"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("my-arn"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -1408,13 +1409,13 @@ func Test_defaultTaggingManager_describeResourceTagsFromAWS(t *testing.T) { describeTagsWithContextCalls: []describeTagsWithContextCall{ { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn1"), awssdk.String("my-arn2")}, + ResourceArns: []string{"my-arn1", "my-arn2"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("my-arn1"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA1"), @@ -1427,7 +1428,7 @@ func Test_defaultTaggingManager_describeResourceTagsFromAWS(t *testing.T) { }, { ResourceArn: awssdk.String("my-arn2"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA2"), @@ -1443,13 +1444,13 @@ func Test_defaultTaggingManager_describeResourceTagsFromAWS(t *testing.T) { }, { req: &elbv2sdk.DescribeTagsInput{ - ResourceArns: []*string{awssdk.String("my-arn3")}, + ResourceArns: []string{"my-arn3"}, }, resp: &elbv2sdk.DescribeTagsOutput{ - TagDescriptions: []*elbv2sdk.TagDescription{ + TagDescriptions: []elbv2types.TagDescription{ { ResourceArn: awssdk.String("my-arn3"), - Tags: []*elbv2sdk.Tag{ + Tags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA3"), @@ -1518,7 +1519,7 @@ func Test_convertTagsToSDKTags(t *testing.T) { tests := []struct { name string args args - want []*elbv2sdk.Tag + want []elbv2types.Tag }{ { name: "non-empty case", @@ -1528,7 +1529,7 @@ func Test_convertTagsToSDKTags(t *testing.T) { "keyB": "valueB", }, }, - want: []*elbv2sdk.Tag{ + want: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -1560,7 +1561,7 @@ func Test_convertTagsToSDKTags(t *testing.T) { func Test_convertSDKTagsToTags(t *testing.T) { type args struct { - sdkTags []*elbv2sdk.Tag + sdkTags []elbv2types.Tag } tests := []struct { name string @@ -1570,7 +1571,7 @@ func Test_convertSDKTagsToTags(t *testing.T) { { name: "non-empty case", args: args{ - sdkTags: []*elbv2sdk.Tag{ + sdkTags: []elbv2types.Tag{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -1596,7 +1597,7 @@ func Test_convertSDKTagsToTags(t *testing.T) { { name: "empty case", args: args{ - sdkTags: []*elbv2sdk.Tag{}, + sdkTags: []elbv2types.Tag{}, }, want: map[string]string{}, }, diff --git a/pkg/deploy/elbv2/target_group_attributes_reconciler.go b/pkg/deploy/elbv2/target_group_attributes_reconciler.go index cc37da7756..7b29f761b6 100644 --- a/pkg/deploy/elbv2/target_group_attributes_reconciler.go +++ b/pkg/deploy/elbv2/target_group_attributes_reconciler.go @@ -2,8 +2,9 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" @@ -47,7 +48,7 @@ func (r *defaultTargetGroupAttributeReconciler) Reconcile(ctx context.Context, r Attributes: nil, } for _, attrKey := range sets.StringKeySet(attributesToUpdate).List() { - req.Attributes = append(req.Attributes, &elbv2sdk.TargetGroupAttribute{ + req.Attributes = append(req.Attributes, elbv2types.TargetGroupAttribute{ Key: awssdk.String(attrKey), Value: awssdk.String(attributesToUpdate[attrKey]), }) @@ -56,7 +57,7 @@ func (r *defaultTargetGroupAttributeReconciler) Reconcile(ctx context.Context, r r.logger.Info("modifying targetGroup attributes", "stackID", resTG.Stack().StackID(), "resourceID", resTG.ID(), - "arn", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn), + "arn", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn), "change", attributesToUpdate) if _, err := r.elbv2Client.ModifyTargetGroupAttributesWithContext(ctx, req); err != nil { return err @@ -64,7 +65,7 @@ func (r *defaultTargetGroupAttributeReconciler) Reconcile(ctx context.Context, r r.logger.Info("modified targetGroup attributes", "stackID", resTG.Stack().StackID(), "resourceID", resTG.ID(), - "arn", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn)) + "arn", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn)) } return nil } @@ -89,7 +90,7 @@ func (r *defaultTargetGroupAttributeReconciler) getCurrentTargetGroupAttributes( tgAttributes := make(map[string]string, len(resp.Attributes)) for _, attr := range resp.Attributes { - tgAttributes[awssdk.StringValue(attr.Key)] = awssdk.StringValue(attr.Value) + tgAttributes[awssdk.ToString(attr.Key)] = awssdk.ToString(attr.Value) } return tgAttributes, nil } diff --git a/pkg/deploy/elbv2/target_group_attributes_reconciler_test.go b/pkg/deploy/elbv2/target_group_attributes_reconciler_test.go index 08a64a4400..5517bf1aa6 100644 --- a/pkg/deploy/elbv2/target_group_attributes_reconciler_test.go +++ b/pkg/deploy/elbv2/target_group_attributes_reconciler_test.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -54,7 +55,7 @@ func Test_defaultTargetGroupAttributeReconciler_Reconcile(t *testing.T) { TargetGroupArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeTargetGroupAttributesOutput{ - Attributes: []*elbv2sdk.TargetGroupAttribute{ + Attributes: []elbv2types.TargetGroupAttribute{ { Key: awssdk.String("slow_start.duration_second"), Value: awssdk.String("50"), @@ -71,7 +72,7 @@ func Test_defaultTargetGroupAttributeReconciler_Reconcile(t *testing.T) { { req: &elbv2sdk.ModifyTargetGroupAttributesInput{ TargetGroupArn: awssdk.String("my-arn"), - Attributes: []*elbv2sdk.TargetGroupAttribute{ + Attributes: []elbv2types.TargetGroupAttribute{ { Key: awssdk.String("slow_start.duration_second"), Value: awssdk.String("100"), @@ -87,7 +88,7 @@ func Test_defaultTargetGroupAttributeReconciler_Reconcile(t *testing.T) { }, args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("my-arn"), }, }, @@ -117,7 +118,7 @@ func Test_defaultTargetGroupAttributeReconciler_Reconcile(t *testing.T) { TargetGroupArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeTargetGroupAttributesOutput{ - Attributes: []*elbv2sdk.TargetGroupAttribute{ + Attributes: []elbv2types.TargetGroupAttribute{ { Key: awssdk.String("slow_start.duration_second"), Value: awssdk.String("50"), @@ -134,7 +135,7 @@ func Test_defaultTargetGroupAttributeReconciler_Reconcile(t *testing.T) { }, args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("my-arn"), }, }, @@ -258,7 +259,7 @@ func Test_defaultTargetGroupAttributeReconciler_getCurrentTargetGroupAttributes( TargetGroupArn: awssdk.String("my-arn"), }, resp: &elbv2sdk.DescribeTargetGroupAttributesOutput{ - Attributes: []*elbv2sdk.TargetGroupAttribute{ + Attributes: []elbv2types.TargetGroupAttribute{ { Key: awssdk.String("keyA"), Value: awssdk.String("valueA"), @@ -274,7 +275,7 @@ func Test_defaultTargetGroupAttributeReconciler_getCurrentTargetGroupAttributes( }, args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("my-arn"), }, Tags: nil, @@ -299,7 +300,7 @@ func Test_defaultTargetGroupAttributeReconciler_getCurrentTargetGroupAttributes( }, args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("my-arn"), }, Tags: nil, diff --git a/pkg/deploy/elbv2/target_group_binding_manager.go b/pkg/deploy/elbv2/target_group_binding_manager.go index 8a7fdab018..1787177190 100644 --- a/pkg/deploy/elbv2/target_group_binding_manager.go +++ b/pkg/deploy/elbv2/target_group_binding_manager.go @@ -2,7 +2,7 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -142,7 +142,7 @@ func (m *defaultTargetGroupBindingManager) waitUntilTargetGroupBindingObserved(c if err := m.k8sClient.Get(ctx, k8s.NamespacedName(tgb), observedTGB); err != nil { return false, err } - if awssdk.Int64Value(observedTGB.Status.ObservedGeneration) >= tgb.Generation { + if awssdk.ToInt64(observedTGB.Status.ObservedGeneration) >= tgb.Generation { return true, nil } @@ -186,7 +186,7 @@ func buildK8sTargetGroupBindingSpec(ctx context.Context, resTGB *elbv2model.Targ k8sTGBSpec.Networking = &k8sTGBNetworking } k8sTGBSpec.NodeSelector = resTGB.Spec.Template.Spec.NodeSelector - k8sTGBSpec.IPAddressType = resTGB.Spec.Template.Spec.IPAddressType + k8sTGBSpec.IPAddressType = &resTGB.Spec.Template.Spec.IPAddressType k8sTGBSpec.VpcID = resTGB.Spec.Template.Spec.VpcID return k8sTGBSpec, nil } diff --git a/pkg/deploy/elbv2/target_group_manager.go b/pkg/deploy/elbv2/target_group_manager.go index d6e658919a..715290473a 100644 --- a/pkg/deploy/elbv2/target_group_manager.go +++ b/pkg/deploy/elbv2/target_group_manager.go @@ -2,9 +2,10 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" + "github.com/aws/smithy-go" "github.com/go-logr/logr" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -76,13 +77,13 @@ func (m *defaultTargetGroupManager) Create(ctx context.Context, resTG *elbv2mode return elbv2model.TargetGroupStatus{}, err } sdkTG := TargetGroupWithTags{ - TargetGroup: resp.TargetGroups[0], + TargetGroup: &resp.TargetGroups[0], Tags: tgTags, } m.logger.Info("created targetGroup", "stackID", resTG.Stack().StackID(), "resourceID", resTG.ID(), - "arn", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn)) + "arn", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn)) if err := m.attributesReconciler.Reconcile(ctx, resTG, sdkTG); err != nil { return elbv2model.TargetGroupStatus{}, err } @@ -110,7 +111,7 @@ func (m *defaultTargetGroupManager) Delete(ctx context.Context, sdkTG TargetGrou } m.logger.Info("deleting targetGroup", - "arn", awssdk.StringValue(req.TargetGroupArn)) + "arn", awssdk.ToString(req.TargetGroupArn)) if err := runtime.RetryImmediateOnError(m.waitTGDeletionPollInterval, m.waitTGDeletionTimeout, isTargetGroupResourceInUseError, func() error { _, err := m.elbv2Client.DeleteTargetGroupWithContext(ctx, req) return err @@ -118,7 +119,7 @@ func (m *defaultTargetGroupManager) Delete(ctx context.Context, sdkTG TargetGrou return errors.Wrap(err, "failed to delete targetGroup") } m.logger.Info("deleted targetGroup", - "arn", awssdk.StringValue(req.TargetGroupArn)) + "arn", awssdk.ToString(req.TargetGroupArn)) return nil } @@ -133,21 +134,21 @@ func (m *defaultTargetGroupManager) updateSDKTargetGroupWithHealthCheck(ctx cont m.logger.Info("modifying targetGroup healthCheck", "stackID", resTG.Stack().StackID(), "resourceID", resTG.ID(), - "arn", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn)) + "arn", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn)) if _, err := m.elbv2Client.ModifyTargetGroupWithContext(ctx, req); err != nil { return err } m.logger.Info("modified targetGroup healthCheck", "stackID", resTG.Stack().StackID(), "resourceID", resTG.ID(), - "arn", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn)) + "arn", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn)) return nil } func (m *defaultTargetGroupManager) updateSDKTargetGroupWithTags(ctx context.Context, resTG *elbv2model.TargetGroup, sdkTG TargetGroupWithTags) error { desiredTGTags := m.trackingProvider.ResourceTags(resTG.Stack(), resTG, resTG.Spec.Tags) - return m.taggingManager.ReconcileTags(ctx, awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn), desiredTGTags, + return m.taggingManager.ReconcileTags(ctx, awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn), desiredTGTags, WithCurrentTags(sdkTG.Tags), WithIgnoredTagKeys(m.trackingProvider.LegacyTagKeys()), WithIgnoredTagKeys(m.externalManagedTags)) @@ -159,28 +160,28 @@ func isSDKTargetGroupHealthCheckDrifted(tgSpec elbv2model.TargetGroupSpec, sdkTG } sdkObj := sdkTG.TargetGroup hcConfig := *tgSpec.HealthCheckConfig - if hcConfig.Port != nil && hcConfig.Port.String() != awssdk.StringValue(sdkObj.HealthCheckPort) { + if hcConfig.Port != nil && hcConfig.Port.String() != awssdk.ToString(sdkObj.HealthCheckPort) { return true } - if hcConfig.Protocol != nil && string(*hcConfig.Protocol) != awssdk.StringValue(sdkObj.HealthCheckProtocol) { + if &hcConfig.Protocol != nil && string(hcConfig.Protocol) != string(sdkObj.HealthCheckProtocol) { return true } - if hcConfig.Path != nil && awssdk.StringValue(hcConfig.Path) != awssdk.StringValue(sdkObj.HealthCheckPath) { + if hcConfig.Path != nil && awssdk.ToString(hcConfig.Path) != awssdk.ToString(sdkObj.HealthCheckPath) { return true } - if hcConfig.Matcher != nil && (sdkObj.Matcher == nil || awssdk.StringValue(hcConfig.Matcher.GRPCCode) != awssdk.StringValue(sdkObj.Matcher.GrpcCode) || awssdk.StringValue(hcConfig.Matcher.HTTPCode) != awssdk.StringValue(sdkObj.Matcher.HttpCode)) { + if hcConfig.Matcher != nil && (sdkObj.Matcher == nil || awssdk.ToString(hcConfig.Matcher.GRPCCode) != awssdk.ToString(sdkObj.Matcher.GrpcCode) || awssdk.ToString(hcConfig.Matcher.HTTPCode) != awssdk.ToString(sdkObj.Matcher.HttpCode)) { return true } - if hcConfig.IntervalSeconds != nil && awssdk.Int64Value(hcConfig.IntervalSeconds) != awssdk.Int64Value(sdkObj.HealthCheckIntervalSeconds) { + if hcConfig.IntervalSeconds != nil && awssdk.ToInt32(hcConfig.IntervalSeconds) != awssdk.ToInt32(sdkObj.HealthCheckIntervalSeconds) { return true } - if hcConfig.TimeoutSeconds != nil && awssdk.Int64Value(hcConfig.TimeoutSeconds) != awssdk.Int64Value(sdkObj.HealthCheckTimeoutSeconds) { + if hcConfig.TimeoutSeconds != nil && awssdk.ToInt32(hcConfig.TimeoutSeconds) != awssdk.ToInt32(sdkObj.HealthCheckTimeoutSeconds) { return true } - if hcConfig.HealthyThresholdCount != nil && awssdk.Int64Value(hcConfig.HealthyThresholdCount) != awssdk.Int64Value(sdkObj.HealthyThresholdCount) { + if hcConfig.HealthyThresholdCount != nil && awssdk.ToInt32(hcConfig.HealthyThresholdCount) != awssdk.ToInt32(sdkObj.HealthyThresholdCount) { return true } - if hcConfig.UnhealthyThresholdCount != nil && awssdk.Int64Value(hcConfig.UnhealthyThresholdCount) != awssdk.Int64Value(sdkObj.UnhealthyThresholdCount) { + if hcConfig.UnhealthyThresholdCount != nil && awssdk.ToInt32(hcConfig.UnhealthyThresholdCount) != awssdk.ToInt32(sdkObj.UnhealthyThresholdCount) { return true } return false @@ -189,11 +190,11 @@ func isSDKTargetGroupHealthCheckDrifted(tgSpec elbv2model.TargetGroupSpec, sdkTG func buildSDKCreateTargetGroupInput(tgSpec elbv2model.TargetGroupSpec) *elbv2sdk.CreateTargetGroupInput { sdkObj := &elbv2sdk.CreateTargetGroupInput{} sdkObj.Name = awssdk.String(tgSpec.Name) - sdkObj.TargetType = awssdk.String(string(tgSpec.TargetType)) - sdkObj.Port = awssdk.Int64(tgSpec.Port) - sdkObj.Protocol = awssdk.String(string(tgSpec.Protocol)) - if tgSpec.IPAddressType != nil && *tgSpec.IPAddressType != elbv2model.TargetGroupIPAddressTypeIPv4 { - sdkObj.IpAddressType = (*string)(tgSpec.IPAddressType) + sdkObj.TargetType = elbv2types.TargetTypeEnum(tgSpec.TargetType) + sdkObj.Port = tgSpec.Port + sdkObj.Protocol = elbv2types.ProtocolEnum(tgSpec.Protocol) + if &tgSpec.IPAddressType != nil && tgSpec.IPAddressType != elbv2model.TargetGroupIPAddressTypeIPv4 { + sdkObj.IpAddressType = elbv2types.TargetGroupIpAddressTypeEnum(tgSpec.IPAddressType) } if tgSpec.ProtocolVersion != nil { sdkObj.ProtocolVersion = (*string)(tgSpec.ProtocolVersion) @@ -204,7 +205,7 @@ func buildSDKCreateTargetGroupInput(tgSpec elbv2model.TargetGroupSpec) *elbv2sdk if hcConfig.Port != nil { sdkObj.HealthCheckPort = awssdk.String(hcConfig.Port.String()) } - sdkObj.HealthCheckProtocol = (*string)(hcConfig.Protocol) + sdkObj.HealthCheckProtocol = elbv2types.ProtocolEnum(hcConfig.Protocol) sdkObj.HealthCheckPath = hcConfig.Path if tgSpec.HealthCheckConfig.Matcher != nil { sdkObj.Matcher = buildSDKMatcher(*hcConfig.Matcher) @@ -226,7 +227,7 @@ func buildSDKModifyTargetGroupInput(tgSpec elbv2model.TargetGroupSpec) *elbv2sdk if hcConfig.Port != nil { sdkObj.HealthCheckPort = awssdk.String(hcConfig.Port.String()) } - sdkObj.HealthCheckProtocol = (*string)(hcConfig.Protocol) + sdkObj.HealthCheckProtocol = elbv2types.ProtocolEnum(hcConfig.Protocol) sdkObj.HealthCheckPath = hcConfig.Path if tgSpec.HealthCheckConfig.Matcher != nil { sdkObj.Matcher = buildSDKMatcher(*hcConfig.Matcher) @@ -239,8 +240,8 @@ func buildSDKModifyTargetGroupInput(tgSpec elbv2model.TargetGroupSpec) *elbv2sdk return sdkObj } -func buildSDKMatcher(modelMatcher elbv2model.HealthCheckMatcher) *elbv2sdk.Matcher { - return &elbv2sdk.Matcher{ +func buildSDKMatcher(modelMatcher elbv2model.HealthCheckMatcher) *elbv2types.Matcher { + return &elbv2types.Matcher{ GrpcCode: modelMatcher.GRPCCode, HttpCode: modelMatcher.HTTPCode, } @@ -248,14 +249,20 @@ func buildSDKMatcher(modelMatcher elbv2model.HealthCheckMatcher) *elbv2sdk.Match func buildResTargetGroupStatus(sdkTG TargetGroupWithTags) elbv2model.TargetGroupStatus { return elbv2model.TargetGroupStatus{ - TargetGroupARN: awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn), + TargetGroupARN: awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn), } } func isTargetGroupResourceInUseError(err error) bool { - var awsErr awserr.Error + var awsErr *elbv2types.ResourceInUseException if errors.As(err, &awsErr) { - return awsErr.Code() == "ResourceInUse" + return true + } + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + code := apiErr.ErrorCode() + + return code == "ResourceInUse" } return false } diff --git a/pkg/deploy/elbv2/target_group_manager_test.go b/pkg/deploy/elbv2/target_group_manager_test.go index 09eb779af5..62e7cf0fd4 100644 --- a/pkg/deploy/elbv2/target_group_manager_test.go +++ b/pkg/deploy/elbv2/target_group_manager_test.go @@ -1,9 +1,10 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" + "github.com/aws/smithy-go" "github.com/pkg/errors" "github.com/stretchr/testify/assert" "k8s.io/apimachinery/pkg/util/intstr" @@ -29,30 +30,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -64,30 +65,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9091"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -99,30 +100,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("TCP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumTcp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -134,30 +135,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/some-other-path"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -169,30 +170,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("503")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("503")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -204,30 +205,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{GRPCCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{GrpcCode: awssdk.String("503")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{GrpcCode: awssdk.String("503")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -239,30 +240,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(11), + HealthCheckIntervalSeconds: awssdk.Int32(11), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -274,30 +275,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(6), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(6), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -309,30 +310,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(4), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(4), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -344,30 +345,30 @@ func Test_isSDKTargetGroupHealthCheckDrifted(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(3), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(3), }, }, }, @@ -402,35 +403,35 @@ func Test_buildSDKCreateTargetGroupInput(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, - IPAddressType: &ipAddressTypeIPv4, + IPAddressType: ipAddressTypeIPv4, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, want: &elbv2sdk.CreateTargetGroupInput{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), Name: awssdk.String("my-tg"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), - TargetType: awssdk.String("ip"), + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, + TargetType: elbv2types.TargetTypeEnumIp, }, }, { @@ -439,36 +440,36 @@ func Test_buildSDKCreateTargetGroupInput(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, ProtocolVersion: &protocolVersionHTTP2, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, want: &elbv2sdk.CreateTargetGroupInput{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), Name: awssdk.String("my-tg"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, ProtocolVersion: awssdk.String("HTTP2"), - TargetType: awssdk.String("ip"), + TargetType: elbv2types.TargetTypeEnumIp, }, }, { @@ -477,36 +478,36 @@ func Test_buildSDKCreateTargetGroupInput(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, - IPAddressType: &ipAddressTypeIPv6, + IPAddressType: ipAddressTypeIPv6, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, want: &elbv2sdk.CreateTargetGroupInput{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), Name: awssdk.String("my-tg"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), - TargetType: awssdk.String("ip"), - IpAddressType: awssdk.String("ipv6"), + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, + TargetType: elbv2types.TargetTypeEnumIp, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, }, }, } @@ -535,30 +536,30 @@ func Test_buildSDKModifyTargetGroupInput(t *testing.T) { tgSpec: elbv2model.TargetGroupSpec{ Name: "my-tg", TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port9090, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/healthcheck"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, want: &elbv2sdk.ModifyTargetGroupInput{ HealthCheckEnabled: awssdk.Bool(true), - HealthCheckIntervalSeconds: awssdk.Int64(10), + HealthCheckIntervalSeconds: awssdk.Int32(10), HealthCheckPath: awssdk.String("/healthcheck"), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - Matcher: &elbv2sdk.Matcher{HttpCode: awssdk.String("200")}, - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + Matcher: &elbv2types.Matcher{HttpCode: awssdk.String("200")}, + UnhealthyThresholdCount: awssdk.Int32(2), }, }, } @@ -578,7 +579,7 @@ func Test_buildSDKMatcher(t *testing.T) { tests := []struct { name string args args - want *elbv2sdk.Matcher + want *elbv2types.Matcher }{ { name: "standard case", @@ -588,7 +589,7 @@ func Test_buildSDKMatcher(t *testing.T) { }, protocolVersion: elbv2model.ProtocolVersionHTTP1, }, - want: &elbv2sdk.Matcher{ + want: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, }, @@ -600,7 +601,7 @@ func Test_buildSDKMatcher(t *testing.T) { }, protocolVersion: elbv2model.ProtocolVersionGRPC, }, - want: &elbv2sdk.Matcher{ + want: &elbv2types.Matcher{ GrpcCode: awssdk.String("2"), }, }, @@ -626,7 +627,7 @@ func Test_buildResTargetGroupStatus(t *testing.T) { name: "standard case", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("my-arn"), }, }, @@ -654,14 +655,14 @@ func Test_isTargetGroupResourceInUseError(t *testing.T) { { name: "is ResourceInUse error", args: args{ - err: awserr.New("ResourceInUse", "some message", nil), + err: &smithy.GenericAPIError{Code: "ResourceInUse", Message: "some message"}, }, want: true, }, { name: "wraps ResourceInUse error", args: args{ - err: errors.Wrap(awserr.New("ResourceInUse", "some message", nil), "wrapped message"), + err: errors.Wrap(&smithy.GenericAPIError{Code: "ResourceInUse", Message: "some message"}, "wrapped message"), }, want: true, }, diff --git a/pkg/deploy/elbv2/target_group_synthesizer.go b/pkg/deploy/elbv2/target_group_synthesizer.go index af4c63e52a..690dae5a29 100644 --- a/pkg/deploy/elbv2/target_group_synthesizer.go +++ b/pkg/deploy/elbv2/target_group_synthesizer.go @@ -2,7 +2,7 @@ package elbv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/sets" @@ -154,7 +154,7 @@ func mapSDKTargetGroupByResourceID(sdkTGs []TargetGroupWithTags, resourceIDTagKe for _, sdkTG := range sdkTGs { resourceID, ok := sdkTG.Tags[resourceIDTagKey] if !ok { - return nil, errors.Errorf("unexpected targetGroup with no resourceID: %v", awssdk.StringValue(sdkTG.TargetGroup.TargetGroupArn)) + return nil, errors.Errorf("unexpected targetGroup with no resourceID: %v", awssdk.ToString(sdkTG.TargetGroup.TargetGroupArn)) } sdkTGsByID[resourceID] = append(sdkTGsByID[resourceID], sdkTG) } @@ -163,14 +163,14 @@ func mapSDKTargetGroupByResourceID(sdkTGs []TargetGroupWithTags, resourceIDTagKe // isSDKTargetGroupRequiresReplacement checks whether a sdk TargetGroup requires replacement to fulfill a TargetGroup resource. func isSDKTargetGroupRequiresReplacement(sdkTG TargetGroupWithTags, resTG *elbv2model.TargetGroup, featureGates config.FeatureGates) bool { - if string(resTG.Spec.TargetType) != awssdk.StringValue(sdkTG.TargetGroup.TargetType) { + if string(resTG.Spec.TargetType) != string(sdkTG.TargetGroup.TargetType) { return true } - if string(resTG.Spec.Protocol) != awssdk.StringValue(sdkTG.TargetGroup.Protocol) { + if string(resTG.Spec.Protocol) != string(sdkTG.TargetGroup.Protocol) { return true } if resTG.Spec.ProtocolVersion != nil { - if string(*resTG.Spec.ProtocolVersion) != awssdk.StringValue(sdkTG.TargetGroup.ProtocolVersion) { + if string(*resTG.Spec.ProtocolVersion) != awssdk.ToString(sdkTG.TargetGroup.ProtocolVersion) { return true } } @@ -189,16 +189,16 @@ func isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(sdkTG TargetGroupWit } sdkObj := sdkTG.TargetGroup hcConfig := *resTG.Spec.HealthCheckConfig - if hcConfig.Protocol != nil && string(*hcConfig.Protocol) != awssdk.StringValue(sdkObj.HealthCheckProtocol) { + if &hcConfig.Protocol != nil && string(hcConfig.Protocol) != string(sdkObj.HealthCheckProtocol) { return true } - if hcConfig.Matcher != nil && (sdkObj.Matcher == nil || awssdk.StringValue(hcConfig.Matcher.GRPCCode) != awssdk.StringValue(sdkObj.Matcher.GrpcCode) || awssdk.StringValue(hcConfig.Matcher.HTTPCode) != awssdk.StringValue(sdkObj.Matcher.HttpCode)) { + if hcConfig.Matcher != nil && (sdkObj.Matcher == nil || awssdk.ToString(hcConfig.Matcher.GRPCCode) != awssdk.ToString(sdkObj.Matcher.GrpcCode) || awssdk.ToString(hcConfig.Matcher.HTTPCode) != awssdk.ToString(sdkObj.Matcher.HttpCode)) { return true } - if hcConfig.IntervalSeconds != nil && awssdk.Int64Value(hcConfig.IntervalSeconds) != awssdk.Int64Value(sdkObj.HealthCheckIntervalSeconds) { + if hcConfig.IntervalSeconds != nil && awssdk.ToInt32(hcConfig.IntervalSeconds) != awssdk.ToInt32(sdkObj.HealthCheckIntervalSeconds) { return true } - if hcConfig.TimeoutSeconds != nil && awssdk.Int64Value(hcConfig.TimeoutSeconds) != awssdk.Int64Value(sdkObj.HealthCheckTimeoutSeconds) { + if hcConfig.TimeoutSeconds != nil && awssdk.ToInt32(hcConfig.TimeoutSeconds) != awssdk.ToInt32(sdkObj.HealthCheckTimeoutSeconds) { return true } return false diff --git a/pkg/deploy/elbv2/target_group_synthesizer_test.go b/pkg/deploy/elbv2/target_group_synthesizer_test.go index c8da143883..eb078fc9db 100644 --- a/pkg/deploy/elbv2/target_group_synthesizer_test.go +++ b/pkg/deploy/elbv2/target_group_synthesizer_test.go @@ -1,8 +1,8 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/pkg/errors" "github.com/stretchr/testify/assert" "k8s.io/apimachinery/pkg/util/intstr" @@ -46,7 +46,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -54,7 +54,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -73,7 +73,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -89,7 +89,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -118,7 +118,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -137,7 +137,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -168,7 +168,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -176,7 +176,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -195,7 +195,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -206,7 +206,7 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, want2: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -229,18 +229,18 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnum("instance"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), - TargetType: awssdk.String("ip"), + TargetType: elbv2types.TargetTypeEnum("ip"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -259,9 +259,9 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, }, sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), - TargetType: awssdk.String("ip"), + TargetType: elbv2types.TargetTypeEnum("ip"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -271,9 +271,9 @@ func Test_matchResAndSDKTargetGroups(t *testing.T) { }, want2: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnum("instance"), }, Tags: map[string]string{ "ingress.k8s.aws/resource": "id-1", @@ -366,7 +366,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { args: args{ sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -374,7 +374,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -387,7 +387,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { want: map[string][]TargetGroupWithTags{ "id-1": { { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -397,7 +397,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, "id-2": { { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2"), }, Tags: map[string]string{ @@ -412,7 +412,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { args: args{ sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -420,7 +420,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2A"), }, Tags: map[string]string{ @@ -428,7 +428,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2B"), }, Tags: map[string]string{ @@ -441,7 +441,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { want: map[string][]TargetGroupWithTags{ "id-1": { { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{ @@ -451,7 +451,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, "id-2": { { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2A"), }, Tags: map[string]string{ @@ -459,7 +459,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { }, }, { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-2B"), }, Tags: map[string]string{ @@ -474,7 +474,7 @@ func Test_mapSDKTargetGroupByResourceID(t *testing.T) { args: args{ sdkTGs: []TargetGroupWithTags{ { - TargetGroup: &elbv2sdk.TargetGroup{ + TargetGroup: &elbv2types.TargetGroup{ TargetGroupArn: awssdk.String("arn-1"), }, Tags: map[string]string{}, @@ -514,17 +514,17 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "targetGroup don't need replacement", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - TargetType: awssdk.String("ip"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), + TargetGroup: &elbv2types.TargetGroup{ + TargetType: elbv2types.TargetTypeEnumIp, + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, TargetGroupName: awssdk.String("my-tg"), }, }, resTG: &elbv2model.TargetGroup{ Spec: elbv2model.TargetGroupSpec{ TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, Name: "my-tg", }, @@ -536,17 +536,17 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "name-only change shouldn't need replacement", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - TargetType: awssdk.String("ip"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), + TargetGroup: &elbv2types.TargetGroup{ + TargetType: elbv2types.TargetTypeEnumIp, + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, TargetGroupName: awssdk.String("my-tg1"), }, }, resTG: &elbv2model.TargetGroup{ Spec: elbv2model.TargetGroupSpec{ TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, Name: "my-tg", }, @@ -558,17 +558,17 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "port-only change shouldn't need replacement", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - TargetType: awssdk.String("ip"), - Port: awssdk.Int64(9090), - Protocol: awssdk.String("HTTP"), + TargetGroup: &elbv2types.TargetGroup{ + TargetType: elbv2types.TargetTypeEnumIp, + Port: awssdk.Int32(9090), + Protocol: elbv2types.ProtocolEnumHttp, TargetGroupName: awssdk.String("my-tg"), }, }, resTG: &elbv2model.TargetGroup{ Spec: elbv2model.TargetGroupSpec{ TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, Name: "my-tg", }, @@ -580,17 +580,17 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "targetType change need replacement", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - TargetType: awssdk.String("instance"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("HTTP"), + TargetGroup: &elbv2types.TargetGroup{ + TargetType: elbv2types.TargetTypeEnumInstance, + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumHttp, TargetGroupName: awssdk.String("my-tg"), }, }, resTG: &elbv2model.TargetGroup{ Spec: elbv2model.TargetGroupSpec{ TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, Name: "my-tg", }, @@ -602,17 +602,17 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "protocol change need replacement", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - TargetType: awssdk.String("ip"), - Port: awssdk.Int64(8080), - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + TargetType: elbv2types.TargetTypeEnumIp, + Port: awssdk.Int32(8080), + Protocol: elbv2types.ProtocolEnumTcp, TargetGroupName: awssdk.String("my-tg"), }, }, resTG: &elbv2model.TargetGroup{ Spec: elbv2model.TargetGroupSpec{ TargetType: elbv2model.TargetTypeIP, - Port: 8080, + Port: awssdk.Int32(8080), Protocol: elbv2model.ProtocolHTTP, Name: "my-tg", }, @@ -624,19 +624,19 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { name: "healthCheck change needs no replacement for protocol change", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(11), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(11), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -644,13 +644,13 @@ func Test_isSDKTargetGroupRequiresReplacement(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -684,19 +684,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck haven't changed", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -704,13 +704,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -721,19 +721,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck cannot change protocol without advanced config", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTPS"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttps, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -741,13 +741,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -759,19 +759,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck cannot changed matcher", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("300"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -779,13 +779,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -797,19 +797,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck cannot change intervalSeconds", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(11), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(11), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -817,13 +817,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -835,19 +835,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck cannot change timeoutSecond", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(6), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(6), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -855,13 +855,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -873,19 +873,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck can change port", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("9090"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -893,13 +893,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -910,19 +910,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck can change path", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/some-other"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -930,13 +930,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, @@ -947,19 +947,19 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { name: "NLB TargetGroup healthCheck can change healthyThresholdCount", args: args{ sdkTG: TargetGroupWithTags{ - TargetGroup: &elbv2sdk.TargetGroup{ - Protocol: awssdk.String("TCP"), + TargetGroup: &elbv2types.TargetGroup{ + Protocol: elbv2types.ProtocolEnumTcp, HealthCheckEnabled: awssdk.Bool(true), HealthCheckPort: awssdk.String("8080"), - HealthCheckProtocol: awssdk.String("HTTP"), + HealthCheckProtocol: elbv2types.ProtocolEnumHttp, HealthCheckPath: awssdk.String("/"), - Matcher: &elbv2sdk.Matcher{ + Matcher: &elbv2types.Matcher{ HttpCode: awssdk.String("200"), }, - HealthCheckIntervalSeconds: awssdk.Int64(10), - HealthCheckTimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(4), - UnhealthyThresholdCount: awssdk.Int64(2), + HealthCheckIntervalSeconds: awssdk.Int32(10), + HealthCheckTimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(4), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, resTG: &elbv2model.TargetGroup{ @@ -967,13 +967,13 @@ func Test_isSDKTargetGroupRequiresReplacementDueToNLBHealthCheck(t *testing.T) { Protocol: elbv2model.ProtocolTCP, HealthCheckConfig: &elbv2model.TargetGroupHealthCheckConfig{ Port: &port8080, - Protocol: &protocolHTTP, + Protocol: protocolHTTP, Path: awssdk.String("/"), Matcher: &elbv2model.HealthCheckMatcher{HTTPCode: awssdk.String("200")}, - IntervalSeconds: awssdk.Int64(10), - TimeoutSeconds: awssdk.Int64(5), - HealthyThresholdCount: awssdk.Int64(3), - UnhealthyThresholdCount: awssdk.Int64(2), + IntervalSeconds: awssdk.Int32(10), + TimeoutSeconds: awssdk.Int32(5), + HealthyThresholdCount: awssdk.Int32(3), + UnhealthyThresholdCount: awssdk.Int32(2), }, }, }, diff --git a/pkg/deploy/shield/protection_manager.go b/pkg/deploy/shield/protection_manager.go index aff417505a..12f98529d1 100644 --- a/pkg/deploy/shield/protection_manager.go +++ b/pkg/deploy/shield/protection_manager.go @@ -2,10 +2,11 @@ package shield import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - shieldsdk "github.com/aws/aws-sdk-go/service/shield" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + shieldsdk "github.com/aws/aws-sdk-go-v2/service/shield" + shieldtypes "github.com/aws/aws-sdk-go-v2/service/shield/types" "github.com/go-logr/logr" + "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/cache" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" "time" @@ -73,7 +74,7 @@ func (m *defaultProtectionManager) CreateProtection(ctx context.Context, resourc if err != nil { return "", err } - protectionID := awssdk.StringValue(resp.ProtectionId) + protectionID := awssdk.ToString(resp.ProtectionId) m.logger.Info("enabled shield protection", "resourceARN", resourceARN, "protectionName", protectionName, @@ -117,8 +118,8 @@ func (m *defaultProtectionManager) GetProtection(ctx context.Context, resourceAR resp, err := m.shieldClient.DescribeProtectionWithContext(ctx, req) var protectionInfo *ProtectionInfo if err != nil { - aerr, ok := err.(awserr.Error) - if ok && aerr.Code() == shieldsdk.ErrCodeResourceNotFoundException { + var resourceNotFoundException *shieldtypes.ResourceNotFoundException + if errors.As(err, &resourceNotFoundException) { protectionInfo = nil } else { return nil, err @@ -126,8 +127,8 @@ func (m *defaultProtectionManager) GetProtection(ctx context.Context, resourceAR } if resp.Protection != nil { protectionInfo = &ProtectionInfo{ - Name: awssdk.StringValue(resp.Protection.Name), - ID: awssdk.StringValue(resp.Protection.Id), + Name: awssdk.ToString(resp.Protection.Name), + ID: awssdk.ToString(resp.Protection.Id), } } m.protectionInfoByResourceARNCache.Set(resourceARN, protectionInfo, m.protectionInfoByResourceARNCacheTTL) @@ -137,8 +138,8 @@ func (m *defaultProtectionManager) GetProtection(ctx context.Context, resourceAR func (m *defaultProtectionManager) IsSubscribed(ctx context.Context) (bool, error) { rawCacheItem, exists := m.subscriptionStateCache.Get(subscriptionStateCacheKey) if exists { - subscriptionState := rawCacheItem.(string) - return subscriptionState == shieldsdk.SubscriptionStateActive, nil + subscriptionState := rawCacheItem.(shieldtypes.SubscriptionState) + return shieldtypes.SubscriptionStateActive == subscriptionState, nil } req := &shieldsdk.GetSubscriptionStateInput{} @@ -146,7 +147,7 @@ func (m *defaultProtectionManager) IsSubscribed(ctx context.Context) (bool, erro if err != nil { return false, err } - subscriptionState := awssdk.StringValue(resp.SubscriptionState) + subscriptionState := resp.SubscriptionState m.subscriptionStateCache.Set(subscriptionStateCacheKey, subscriptionState, m.subscriptionStateCacheTTL) - return subscriptionState == shieldsdk.SubscriptionStateActive, nil + return shieldtypes.SubscriptionStateActive == subscriptionState, nil } diff --git a/pkg/deploy/shield/protection_manager_test.go b/pkg/deploy/shield/protection_manager_test.go index 1c2c186ed4..255f1e7c02 100644 --- a/pkg/deploy/shield/protection_manager_test.go +++ b/pkg/deploy/shield/protection_manager_test.go @@ -2,11 +2,11 @@ package shield import ( "context" + shieldtypes "github.com/aws/aws-sdk-go-v2/service/shield/types" "testing" "time" - awssdk "github.com/aws/aws-sdk-go/aws" - shieldsdk "github.com/aws/aws-sdk-go/service/shield" + shieldsdk "github.com/aws/aws-sdk-go-v2/service/shield" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -43,7 +43,7 @@ func Test_defaultProtectionManager_IsSubscribed(t *testing.T) { { req: &shieldsdk.GetSubscriptionStateInput{}, resp: &shieldsdk.GetSubscriptionStateOutput{ - SubscriptionState: awssdk.String(shieldsdk.SubscriptionStateActive), + SubscriptionState: shieldtypes.SubscriptionStateActive, }, }, }, @@ -62,7 +62,7 @@ func Test_defaultProtectionManager_IsSubscribed(t *testing.T) { { req: &shieldsdk.GetSubscriptionStateInput{}, resp: &shieldsdk.GetSubscriptionStateOutput{ - SubscriptionState: awssdk.String(shieldsdk.SubscriptionStateInactive), + SubscriptionState: shieldtypes.SubscriptionStateInactive, }, }, }, @@ -98,7 +98,7 @@ func Test_defaultProtectionManager_IsSubscribed(t *testing.T) { { req: &shieldsdk.GetSubscriptionStateInput{}, resp: &shieldsdk.GetSubscriptionStateOutput{ - SubscriptionState: awssdk.String(shieldsdk.SubscriptionStateInactive), + SubscriptionState: shieldtypes.SubscriptionStateInactive, }, }, }, @@ -120,13 +120,13 @@ func Test_defaultProtectionManager_IsSubscribed(t *testing.T) { { req: &shieldsdk.GetSubscriptionStateInput{}, resp: &shieldsdk.GetSubscriptionStateOutput{ - SubscriptionState: awssdk.String(shieldsdk.SubscriptionStateInactive), + SubscriptionState: shieldtypes.SubscriptionStateInactive, }, }, { req: &shieldsdk.GetSubscriptionStateInput{}, resp: &shieldsdk.GetSubscriptionStateOutput{ - SubscriptionState: awssdk.String(shieldsdk.SubscriptionStateActive), + SubscriptionState: shieldtypes.SubscriptionStateActive, }, }, }, diff --git a/pkg/deploy/wafregional/web_acl_association_manager.go b/pkg/deploy/wafregional/web_acl_association_manager.go index f046400113..2d266fd5e7 100644 --- a/pkg/deploy/wafregional/web_acl_association_manager.go +++ b/pkg/deploy/wafregional/web_acl_association_manager.go @@ -2,8 +2,8 @@ package wafregional import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - wafregionalsdk "github.com/aws/aws-sdk-go/service/wafregional" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + wafregionalsdk "github.com/aws/aws-sdk-go-v2/service/wafregional" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/cache" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -97,7 +97,7 @@ func (m *defaultWebACLAssociationManager) GetAssociatedWebACL(ctx context.Contex } var webACLID string if resp.WebACLSummary != nil { - webACLID = awssdk.StringValue(resp.WebACLSummary.WebACLId) + webACLID = awssdk.ToString(resp.WebACLSummary.WebACLId) } m.webACLIDByResourceARNCache.Set(resourceARN, webACLID, m.webACLIDByResourceARNCacheTTL) diff --git a/pkg/deploy/wafv2/web_acl_association_manager.go b/pkg/deploy/wafv2/web_acl_association_manager.go index c0a684bddd..6c881e8f2d 100644 --- a/pkg/deploy/wafv2/web_acl_association_manager.go +++ b/pkg/deploy/wafv2/web_acl_association_manager.go @@ -2,8 +2,8 @@ package wafv2 import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - wafv2sdk "github.com/aws/aws-sdk-go/service/wafv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + wafv2sdk "github.com/aws/aws-sdk-go-v2/service/wafv2" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/cache" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -97,7 +97,7 @@ func (m *defaultWebACLAssociationManager) GetAssociatedWebACL(ctx context.Contex } var webACLARN string if resp.WebACL != nil { - webACLARN = awssdk.StringValue(resp.WebACL.ARN) + webACLARN = awssdk.ToString(resp.WebACL.ARN) } m.webACLARNByResourceARNCache.Set(resourceARN, webACLARN, m.webACLARNByResourceARNCacheTTL) diff --git a/pkg/equality/elbv2/compare_option_for_actions.go b/pkg/equality/elbv2/compare_option_for_actions.go index 489b4f00f2..b267f59845 100644 --- a/pkg/equality/elbv2/compare_option_for_actions.go +++ b/pkg/equality/elbv2/compare_option_for_actions.go @@ -1,65 +1,73 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" "sigs.k8s.io/aws-load-balancer-controller/pkg/equality" ) func CompareOptionForTargetGroupTuples() cmp.Option { - return cmpopts.AcyclicTransformer("normalizeWeights", func(tgt []*elbv2sdk.TargetGroupTuple) []*elbv2sdk.TargetGroupTuple { - if len(tgt) != 1 { - return tgt - } - singleTG := tgt[0] - return []*elbv2sdk.TargetGroupTuple{ - { - TargetGroupArn: singleTG.TargetGroupArn, - Weight: nil, - }, - } - }) + return cmp.Options{ + cmpopts.IgnoreUnexported(elbv2types.TargetGroupTuple{}), + cmpopts.AcyclicTransformer("normalizeWeights", func(tgt []elbv2types.TargetGroupTuple) []elbv2types.TargetGroupTuple { + if len(tgt) != 1 { + return tgt + } + singleTG := tgt[0] + return []elbv2types.TargetGroupTuple{ + { + TargetGroupArn: singleTG.TargetGroupArn, + Weight: nil, + }, + } + }), + } } func CompareOptionForForwardActionConfig() cmp.Option { return cmp.Options{ - equality.IgnoreLeftHandUnset(elbv2sdk.ForwardActionConfig{}, "TargetGroupStickinessConfig"), + equality.IgnoreLeftHandUnset(elbv2types.ForwardActionConfig{}, "TargetGroupStickinessConfig"), + cmpopts.IgnoreUnexported(elbv2types.ForwardActionConfig{}), CompareOptionForTargetGroupTuples(), } } func CompareOptionForRedirectActionConfig() cmp.Option { - return cmpopts.AcyclicTransformer("normalizeRedirectActionConfig", func(config *elbv2sdk.RedirectActionConfig) *elbv2sdk.RedirectActionConfig { - if config == nil { - return nil - } - normalizedCFG := *config - if normalizedCFG.Host == nil { - normalizedCFG.Host = awssdk.String("#{host}") - } - if normalizedCFG.Path == nil { - normalizedCFG.Path = awssdk.String("/#{path}") - } - if normalizedCFG.Port == nil { - normalizedCFG.Port = awssdk.String("#{port}") - } - if normalizedCFG.Protocol == nil { - normalizedCFG.Protocol = awssdk.String("#{protocol}") - } - if normalizedCFG.Query == nil { - normalizedCFG.Query = awssdk.String("#{query}") - } - return &normalizedCFG - }) + return cmp.Options{ + cmpopts.IgnoreUnexported(elbv2types.RedirectActionConfig{}), + cmpopts.AcyclicTransformer("normalizeRedirectActionConfig", func(config *elbv2types.RedirectActionConfig) *elbv2types.RedirectActionConfig { + if config == nil { + return nil + } + normalizedCFG := *config + if normalizedCFG.Host == nil { + normalizedCFG.Host = awssdk.String("#{host}") + } + if normalizedCFG.Path == nil { + normalizedCFG.Path = awssdk.String("/#{path}") + } + if normalizedCFG.Port == nil { + normalizedCFG.Port = awssdk.String("#{port}") + } + if normalizedCFG.Protocol == nil { + normalizedCFG.Protocol = awssdk.String("#{protocol}") + } + if normalizedCFG.Query == nil { + normalizedCFG.Query = awssdk.String("#{query}") + } + return &normalizedCFG + }), + } } // CompareOptionForAction returns the compare option for action. func CompareOptionForAction() cmp.Option { return cmp.Options{ - cmpopts.IgnoreFields(elbv2sdk.Action{}, "Order"), - cmpopts.IgnoreFields(elbv2sdk.Action{}, "TargetGroupArn"), + cmpopts.IgnoreFields(elbv2types.Action{}, "Order"), + cmpopts.IgnoreFields(elbv2types.Action{}, "TargetGroupArn"), + cmpopts.IgnoreUnexported(elbv2types.Action{}), CompareOptionForForwardActionConfig(), CompareOptionForRedirectActionConfig(), } @@ -69,11 +77,14 @@ func CompareOptionForAction() cmp.Option { func CompareOptionForActions() cmp.Option { return cmp.Options{ cmpopts.EquateEmpty(), - cmpopts.SortSlices(func(lhs *elbv2sdk.Action, rhs *elbv2sdk.Action) bool { + cmpopts.IgnoreUnexported(elbv2types.AuthenticateCognitoActionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.AuthenticateOidcActionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.FixedResponseActionConfig{}), + cmpopts.SortSlices(func(lhs elbv2types.Action, rhs elbv2types.Action) bool { if lhs.Order == nil || rhs.Order == nil { return false } - return awssdk.Int64Value(lhs.Order) < awssdk.Int64Value(rhs.Order) + return awssdk.ToInt32(lhs.Order) < awssdk.ToInt32(rhs.Order) }), CompareOptionForAction(), } diff --git a/pkg/equality/elbv2/compare_option_for_actions_test.go b/pkg/equality/elbv2/compare_option_for_actions_test.go index b68408c855..dafc888441 100644 --- a/pkg/equality/elbv2/compare_option_for_actions_test.go +++ b/pkg/equality/elbv2/compare_option_for_actions_test.go @@ -1,8 +1,8 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/google/go-cmp/cmp" "github.com/stretchr/testify/assert" "testing" @@ -10,8 +10,8 @@ import ( func TestCompareOptionForRedirectActionConfig(t *testing.T) { type args struct { - lhs *elbv2sdk.RedirectActionConfig - rhs *elbv2sdk.RedirectActionConfig + lhs *elbv2types.RedirectActionConfig + rhs *elbv2types.RedirectActionConfig } tests := []struct { name string @@ -21,21 +21,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "equals for all fields", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -43,21 +43,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "host not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("app.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -65,21 +65,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "host not equals with #{host}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("#{host}"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -87,21 +87,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "nil host equals with #{host}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("#{host}"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: nil, Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -109,21 +109,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "path not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/app"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -131,21 +131,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "path not equals with /#{path}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/#{path}"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -153,21 +153,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "nil path equals with /#{path}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/#{path}"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: nil, Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -175,21 +175,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "port not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("443"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -197,21 +197,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "port not equals with #{port}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("#{port}"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -219,21 +219,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "nil port equals with #{port}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("#{port}"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: nil, Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -241,21 +241,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "protocol not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTP"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -263,21 +263,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "protocol not equals with #{protocol}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("#{protocol}"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -285,21 +285,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "nil protocol equals with #{protocol}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("#{protocol}"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: nil, Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -307,21 +307,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "query not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=c"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -329,21 +329,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "query not equals with #{query}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("#{query}"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: false, @@ -351,21 +351,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "nil query equals with #{query}", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("#{query}"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: nil, - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, }, want: true, @@ -373,21 +373,21 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { { name: "statusCode not equals", args: args{ - lhs: &elbv2sdk.RedirectActionConfig{ + lhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_301"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_301"), }, - rhs: &elbv2sdk.RedirectActionConfig{ + rhs: &elbv2types.RedirectActionConfig{ Host: awssdk.String("www.example.com"), Path: awssdk.String("/home"), Port: awssdk.String("80"), Protocol: awssdk.String("HTTPS"), Query: awssdk.String("a=b"), - StatusCode: awssdk.String("HTTP_302"), + StatusCode: elbv2types.RedirectActionStatusCodeEnum("HTTP_302"), }, }, want: false, @@ -412,8 +412,8 @@ func TestCompareOptionForRedirectActionConfig(t *testing.T) { func TestCompareOptionForAction(t *testing.T) { type args struct { - lhs elbv2sdk.Action - rhs elbv2sdk.Action + lhs elbv2types.Action + rhs elbv2types.Action } tests := []struct { name string @@ -423,20 +423,20 @@ func TestCompareOptionForAction(t *testing.T) { { name: "two actions equals exactly", args: args{ - lhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + lhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, }, - rhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + rhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, @@ -449,20 +449,20 @@ func TestCompareOptionForAction(t *testing.T) { { name: "two actions are not equal if some fields un-equal", args: args{ - lhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + lhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, }, - rhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + rhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-b"), }, @@ -475,26 +475,26 @@ func TestCompareOptionForAction(t *testing.T) { { name: "two actions are equal irrelevant of their order existence", args: args{ - lhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + lhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, }, - rhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + rhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, }, want: true, @@ -502,27 +502,27 @@ func TestCompareOptionForAction(t *testing.T) { { name: "two actions are equal irrelevant of their order value", args: args{ - lhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + lhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, - rhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + rhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, want: true, @@ -530,20 +530,20 @@ func TestCompareOptionForAction(t *testing.T) { { name: "two action are equal irrelevant of their targetGroupARN existence", args: args{ - lhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + lhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, }, - rhs: elbv2sdk.Action{ - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + rhs: elbv2types.Action{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, @@ -565,8 +565,8 @@ func TestCompareOptionForAction(t *testing.T) { func TestCompareOptionForActions(t *testing.T) { type args struct { - lhs []*elbv2sdk.Action - rhs []*elbv2sdk.Action + lhs []elbv2types.Action + rhs []elbv2types.Action } tests := []struct { name string @@ -576,48 +576,48 @@ func TestCompareOptionForActions(t *testing.T) { { name: "two actions slice equals exactly", args: args{ - lhs: []*elbv2sdk.Action{ + lhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, - rhs: []*elbv2sdk.Action{ + rhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, }, @@ -626,48 +626,48 @@ func TestCompareOptionForActions(t *testing.T) { { name: "two actions slice are not equal if there actions are not equal", args: args{ - lhs: []*elbv2sdk.Action{ + lhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, - rhs: []*elbv2sdk.Action{ + rhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-b"), UserPoolClientId: awssdk.String("pool-client-id-b"), UserPoolDomain: awssdk.String("pool-domain-b"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, }, @@ -676,48 +676,48 @@ func TestCompareOptionForActions(t *testing.T) { { name: "two actions slice equals when they are equal after sorted by order", args: args{ - lhs: []*elbv2sdk.Action{ + lhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, - rhs: []*elbv2sdk.Action{ + rhs: []elbv2types.Action{ { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(4), + Order: awssdk.Int32(4), }, { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(3), + Order: awssdk.Int32(3), }, }, }, @@ -726,48 +726,48 @@ func TestCompareOptionForActions(t *testing.T) { { name: "two actions slice are not equals when they are not equal after sorted by order", args: args{ - lhs: []*elbv2sdk.Action{ + lhs: []elbv2types.Action{ { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(1), + Order: awssdk.Int32(1), }, { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(2), + Order: awssdk.Int32(2), }, }, - rhs: []*elbv2sdk.Action{ + rhs: []elbv2types.Action{ { - Type: awssdk.String("forward"), - ForwardConfig: &elbv2sdk.ForwardActionConfig{ - TargetGroups: []*elbv2sdk.TargetGroupTuple{ + Type: elbv2types.ActionTypeEnum("forward"), + ForwardConfig: &elbv2types.ForwardActionConfig{ + TargetGroups: []elbv2types.TargetGroupTuple{ { TargetGroupArn: awssdk.String("tg-a"), }, }, }, - Order: awssdk.Int64(3), + Order: awssdk.Int32(3), }, { - Type: awssdk.String("authenticate-cognito"), - AuthenticateCognitoConfig: &elbv2sdk.AuthenticateCognitoActionConfig{ + Type: elbv2types.ActionTypeEnum("authenticate-cognito"), + AuthenticateCognitoConfig: &elbv2types.AuthenticateCognitoActionConfig{ UserPoolArn: awssdk.String("pool-arn-a"), UserPoolClientId: awssdk.String("pool-client-id-a"), UserPoolDomain: awssdk.String("pool-domain-a"), }, - Order: awssdk.Int64(4), + Order: awssdk.Int32(4), }, }, }, diff --git a/pkg/equality/elbv2/compare_option_for_certificates.go b/pkg/equality/elbv2/compare_option_for_certificates.go index 3abde7e757..3d7bb3a19f 100644 --- a/pkg/equality/elbv2/compare_option_for_certificates.go +++ b/pkg/equality/elbv2/compare_option_for_certificates.go @@ -1,22 +1,26 @@ package elbv2 import ( - "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" ) func CompareOptionForCertificate() cmp.Option { - return cmpopts.IgnoreFields(elbv2sdk.Certificate{}, "IsDefault") + return cmp.Options{ + cmpopts.IgnoreFields(elbv2types.Certificate{}, "IsDefault"), + cmpopts.IgnoreUnexported(elbv2types.Certificate{}), + } } func CompareOptionForCertificates() cmp.Options { return cmp.Options{ cmpopts.EquateEmpty(), - cmpopts.SortSlices(func(lhs *elbv2sdk.Certificate, rhs *elbv2sdk.Certificate) bool { - return aws.StringValue(lhs.CertificateArn) < aws.StringValue(rhs.CertificateArn) + cmpopts.SortSlices(func(lhs *elbv2types.Certificate, rhs *elbv2types.Certificate) bool { + return aws.ToString(lhs.CertificateArn) < aws.ToString(rhs.CertificateArn) }), + cmpopts.IgnoreUnexported(elbv2types.Certificate{}), CompareOptionForCertificate(), } } diff --git a/pkg/equality/elbv2/compare_option_for_certificates_test.go b/pkg/equality/elbv2/compare_option_for_certificates_test.go index bdaf6c449b..f139f75fea 100644 --- a/pkg/equality/elbv2/compare_option_for_certificates_test.go +++ b/pkg/equality/elbv2/compare_option_for_certificates_test.go @@ -1,8 +1,8 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/google/go-cmp/cmp" "github.com/stretchr/testify/assert" "testing" @@ -10,8 +10,8 @@ import ( func TestCompareOptionForCertificate(t *testing.T) { type args struct { - lhs elbv2sdk.Certificate - rhs elbv2sdk.Certificate + lhs elbv2types.Certificate + rhs elbv2types.Certificate } tests := []struct { name string @@ -21,10 +21,10 @@ func TestCompareOptionForCertificate(t *testing.T) { { name: "two certificate equals exactly", args: args{ - lhs: elbv2sdk.Certificate{ + lhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-A"), }, - rhs: elbv2sdk.Certificate{ + rhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-A"), }, }, @@ -33,10 +33,10 @@ func TestCompareOptionForCertificate(t *testing.T) { { name: "two certificate are not equals if certARN mismatch", args: args{ - lhs: elbv2sdk.Certificate{ + lhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-A"), }, - rhs: elbv2sdk.Certificate{ + rhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-B"), }, }, @@ -45,10 +45,10 @@ func TestCompareOptionForCertificate(t *testing.T) { { name: "two certificate equals exactly irrelevant of their isDefault", args: args{ - lhs: elbv2sdk.Certificate{ + lhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-A"), }, - rhs: elbv2sdk.Certificate{ + rhs: elbv2types.Certificate{ CertificateArn: awssdk.String("cert-A"), IsDefault: awssdk.Bool(true), }, @@ -66,8 +66,8 @@ func TestCompareOptionForCertificate(t *testing.T) { func TestCompareOptionForCertificates(t *testing.T) { type args struct { - lhs []*elbv2sdk.Certificate - rhs []*elbv2sdk.Certificate + lhs []*elbv2types.Certificate + rhs []*elbv2types.Certificate } tests := []struct { name string @@ -77,12 +77,12 @@ func TestCompareOptionForCertificates(t *testing.T) { { name: "two certificates slice are equal exactly", args: args{ - lhs: []*elbv2sdk.Certificate{ + lhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-A"), }, }, - rhs: []*elbv2sdk.Certificate{ + rhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-A"), }, @@ -93,12 +93,12 @@ func TestCompareOptionForCertificates(t *testing.T) { { name: "two certificates slice are not equal if certARN mismatches", args: args{ - lhs: []*elbv2sdk.Certificate{ + lhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-A"), }, }, - rhs: []*elbv2sdk.Certificate{ + rhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-B"), }, @@ -109,7 +109,7 @@ func TestCompareOptionForCertificates(t *testing.T) { { name: "two certificates slice are equal if they are equal after sorted", args: args{ - lhs: []*elbv2sdk.Certificate{ + lhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-A"), }, @@ -117,7 +117,7 @@ func TestCompareOptionForCertificates(t *testing.T) { CertificateArn: awssdk.String("cert-B"), }, }, - rhs: []*elbv2sdk.Certificate{ + rhs: []*elbv2types.Certificate{ { CertificateArn: awssdk.String("cert-B"), }, @@ -131,7 +131,7 @@ func TestCompareOptionForCertificates(t *testing.T) { { name: "two certificates slice are equal for nil and empty slice", args: args{ - lhs: []*elbv2sdk.Certificate{}, + lhs: []*elbv2types.Certificate{}, rhs: nil, }, want: true, diff --git a/pkg/equality/elbv2/compare_option_for_rule_conditions.go b/pkg/equality/elbv2/compare_option_for_rule_conditions.go index 788980913e..7fd87fe220 100644 --- a/pkg/equality/elbv2/compare_option_for_rule_conditions.go +++ b/pkg/equality/elbv2/compare_option_for_rule_conditions.go @@ -1,15 +1,21 @@ package elbv2 import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" ) func CompareOptionForRuleCondition() cmp.Option { return cmp.Options{ - cmpopts.IgnoreFields(elbv2sdk.RuleCondition{}, "Values"), + cmpopts.IgnoreUnexported(elbv2types.RuleCondition{}), + cmpopts.IgnoreUnexported(elbv2types.HostHeaderConditionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.HttpRequestMethodConditionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.PathPatternConditionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.QueryStringConditionConfig{}), + cmpopts.IgnoreUnexported(elbv2types.SourceIpConditionConfig{}), + cmpopts.IgnoreFields(elbv2types.RuleCondition{}, "Values"), } } @@ -17,8 +23,8 @@ func CompareOptionForRuleCondition() cmp.Option { func CompareOptionForRuleConditions() cmp.Option { return cmp.Options{ cmpopts.EquateEmpty(), - cmpopts.SortSlices(func(lhs *elbv2sdk.RuleCondition, rhs *elbv2sdk.RuleCondition) bool { - return awssdk.StringValue(lhs.Field) < awssdk.StringValue(rhs.Field) + cmpopts.SortSlices(func(lhs *elbv2types.RuleCondition, rhs *elbv2types.RuleCondition) bool { + return awssdk.ToString(lhs.Field) < awssdk.ToString(rhs.Field) }), CompareOptionForRuleCondition(), } diff --git a/pkg/ingress/cert_discovery.go b/pkg/ingress/cert_discovery.go index acca5f6618..8f6ce97e2a 100644 --- a/pkg/ingress/cert_discovery.go +++ b/pkg/ingress/cert_discovery.go @@ -2,13 +2,9 @@ package ingress import ( "context" - "strings" - "sync" - "time" - - "github.com/aws/aws-sdk-go/aws" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/acm" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/acm" + acmTypes "github.com/aws/aws-sdk-go-v2/service/acm/types" "github.com/go-logr/logr" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" @@ -17,6 +13,9 @@ import ( "k8s.io/apimachinery/pkg/util/sets" "k8s.io/utils/strings/slices" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" + "strings" + "sync" + "time" ) const ( @@ -120,9 +119,9 @@ func (d *acmCertDiscovery) loadAllCertificateARNs(ctx context.Context) ([]string return rawCacheItem.([]string), nil } req := &acm.ListCertificatesInput{ - CertificateStatuses: aws.StringSlice([]string{acm.CertificateStatusIssued}), - Includes: &acm.Filters{ - KeyTypes: aws.StringSlice(acm.KeyAlgorithm_Values()), + CertificateStatuses: []acmTypes.CertificateStatus{acmTypes.CertificateStatusIssued}, + Includes: &acmTypes.Filters{ + KeyTypes: acmTypes.KeyAlgorithm.Values(""), }, } certSummaries, err := d.acmClient.ListCertificatesAsList(ctx, req) @@ -132,7 +131,7 @@ func (d *acmCertDiscovery) loadAllCertificateARNs(ctx context.Context) ([]string var certARNs []string for _, certSummary := range certSummaries { - certARN := aws.StringValue(certSummary.CertificateArn) + certARN := awssdk.ToString(certSummary.CertificateArn) certARNs = append(certARNs, certARN) } d.certARNsCache.Set(certARNsCacheKey, certARNs, d.certARNsCacheTTL) @@ -144,7 +143,7 @@ func (d *acmCertDiscovery) loadDomainsForCertificate(ctx context.Context, certAR return rawCacheItem.(sets.String), nil } req := &acm.DescribeCertificateInput{ - CertificateArn: aws.String(certARN), + CertificateArn: awssdk.String(certARN), } resp, err := d.acmClient.DescribeCertificateWithContext(ctx, req) if err != nil { @@ -155,13 +154,13 @@ func (d *acmCertDiscovery) loadDomainsForCertificate(ctx context.Context, certAR // check if cert is issued from an allowed CA // otherwise empty-out the list of domains domains := sets.String{} - if len(d.allowedCAARNs) == 0 || slices.Contains(d.allowedCAARNs, awssdk.StringValue(certDetail.CertificateAuthorityArn)) { - domains = sets.NewString(aws.StringValueSlice(certDetail.SubjectAlternativeNames)...) + if len(d.allowedCAARNs) == 0 || slices.Contains(d.allowedCAARNs, awssdk.ToString(certDetail.CertificateAuthorityArn)) { + domains = sets.NewString(certDetail.SubjectAlternativeNames...) } - switch aws.StringValue(certDetail.Type) { - case acm.CertificateTypeImported: + switch certDetail.Type { + case acmTypes.CertificateTypeImported: d.certDomainsCache.Set(certARN, domains, d.importedCertDomainsCacheTTL) - case acm.CertificateTypeAmazonIssued, acm.CertificateTypePrivate: + case acmTypes.CertificateTypeAmazonIssued, acmTypes.CertificateTypePrivate: d.certDomainsCache.Set(certARN, domains, d.privateCertDomainsCacheTTL) } return domains, nil diff --git a/pkg/ingress/class_loader_test.go b/pkg/ingress/class_loader_test.go index 0a40fb9c18..de7e534530 100644 --- a/pkg/ingress/class_loader_test.go +++ b/pkg/ingress/class_loader_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" "github.com/pkg/errors" diff --git a/pkg/ingress/config_types.go b/pkg/ingress/config_types.go index 6e2da610e7..956e1e9978 100644 --- a/pkg/ingress/config_types.go +++ b/pkg/ingress/config_types.go @@ -1,7 +1,6 @@ package ingress import ( - "github.com/aws/aws-sdk-go/service/elbv2" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/intstr" ) @@ -77,7 +76,7 @@ type TargetGroupTuple struct { // The weight. // +optional - Weight *int64 `json:"weight,omitempty"` + Weight *int32 `json:"weight,omitempty"` } func (t *TargetGroupTuple) validate() error { @@ -99,7 +98,7 @@ type TargetGroupStickinessConfig struct { // The time period, in seconds, during which requests from a client should be routed to the same target group. // +optional - DurationSeconds *int64 `json:"durationSeconds,omitempty"` + DurationSeconds *int32 `json:"durationSeconds,omitempty"` } // Information about a forward action. @@ -162,21 +161,21 @@ type Action struct { func (a *Action) validate() error { switch a.Type { - case elbv2.ActionTypeEnumFixedResponse: + case ActionTypeFixedResponse: if a.FixedResponseConfig == nil { return errors.New("missing FixedResponseConfig") } if err := a.FixedResponseConfig.validate(); err != nil { return errors.Wrap(err, "invalid FixedResponseConfig") } - case elbv2.ActionTypeEnumRedirect: + case ActionTypeRedirect: if a.RedirectConfig == nil { return errors.New("missing RedirectConfig") } if err := a.RedirectConfig.validate(); err != nil { return errors.Wrap(err, "invalid RedirectConfig") } - case elbv2.ActionTypeEnumForward: + case ActionTypeForward: if (a.TargetGroupARN != nil) == (a.ForwardConfig != nil) { return errors.New("precisely one of TargetGroupArn and ForwardConfig can be specified") } diff --git a/pkg/ingress/enhanced_backend_builder.go b/pkg/ingress/enhanced_backend_builder.go index 1b2018c931..2bf87f61ef 100644 --- a/pkg/ingress/enhanced_backend_builder.go +++ b/pkg/ingress/enhanced_backend_builder.go @@ -4,7 +4,7 @@ import ( "context" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" networking "k8s.io/api/networking/v1" @@ -243,7 +243,7 @@ func (b *defaultEnhancedBackendBuilder) loadBackendServices(ctx context.Context, svcNames := sets.NewString() for _, tgt := range action.ForwardConfig.TargetGroups { if tgt.ServiceName != nil { - svcNames.Insert(awssdk.StringValue(tgt.ServiceName)) + svcNames.Insert(awssdk.ToString(tgt.ServiceName)) } } forwardToSingleSvc := (len(action.ForwardConfig.TargetGroups) == 1) && (svcNames.Len() == 1) @@ -275,7 +275,7 @@ func (b *defaultEnhancedBackendBuilder) buildAuthConfig(ctx context.Context, act action.ForwardConfig != nil && len(action.ForwardConfig.TargetGroups) == 1 && action.ForwardConfig.TargetGroups[0].ServiceName != nil { - svcName := awssdk.StringValue(action.ForwardConfig.TargetGroups[0].ServiceName) + svcName := awssdk.ToString(action.ForwardConfig.TargetGroups[0].ServiceName) svcKey := types.NamespacedName{Namespace: namespace, Name: svcName} svc := backendServices[svcKey] svcAndIngAnnotations = algorithm.MergeStringMap(svc.Annotations, svcAndIngAnnotations) diff --git a/pkg/ingress/enhanced_backend_builder_test.go b/pkg/ingress/enhanced_backend_builder_test.go index 35bc4cf8bf..9d8530f74b 100644 --- a/pkg/ingress/enhanced_backend_builder_test.go +++ b/pkg/ingress/enhanced_backend_builder_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/google/go-cmp/cmp" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -1063,21 +1063,21 @@ func Test_defaultEnhancedBackendBuilder_buildActionViaAnnotation(t *testing.T) { { ServiceName: awssdk.String("service-1"), ServicePort: &portHTTP, - Weight: awssdk.Int64(20), + Weight: awssdk.Int32(20), }, { ServiceName: awssdk.String("service-2"), ServicePort: &port80, - Weight: awssdk.Int64(20), + Weight: awssdk.Int32(20), }, { TargetGroupARN: awssdk.String("tg-arn"), - Weight: awssdk.Int64(60), + Weight: awssdk.Int32(60), }, }, TargetGroupStickinessConfig: &TargetGroupStickinessConfig{ Enabled: awssdk.Bool(true), - DurationSeconds: awssdk.Int64(200), + DurationSeconds: awssdk.Int32(200), }, }, }, @@ -1097,21 +1097,21 @@ func Test_defaultEnhancedBackendBuilder_buildActionViaAnnotation(t *testing.T) { { ServiceName: awssdk.String("service-1"), ServicePort: &portHTTP, - Weight: awssdk.Int64(20), + Weight: awssdk.Int32(20), }, { ServiceName: awssdk.String("service-2"), ServicePort: &port80, - Weight: awssdk.Int64(20), + Weight: awssdk.Int32(20), }, { TargetGroupARN: awssdk.String("tg-arn"), - Weight: awssdk.Int64(60), + Weight: awssdk.Int32(60), }, }, TargetGroupStickinessConfig: &TargetGroupStickinessConfig{ Enabled: awssdk.Bool(true), - DurationSeconds: awssdk.Int64(200), + DurationSeconds: awssdk.Int32(200), }, }, }, @@ -1131,12 +1131,12 @@ func Test_defaultEnhancedBackendBuilder_buildActionViaAnnotation(t *testing.T) { { ServiceName: awssdk.String("service-1"), ServicePort: &port80, - Weight: awssdk.Int64(40), + Weight: awssdk.Int32(40), }, { ServiceName: awssdk.String("service-2"), ServicePort: &port443, - Weight: awssdk.Int64(60), + Weight: awssdk.Int32(60), }, }, }, diff --git a/pkg/ingress/group_loader.go b/pkg/ingress/group_loader.go index a4b1a50ef5..2bd98ab61a 100644 --- a/pkg/ingress/group_loader.go +++ b/pkg/ingress/group_loader.go @@ -16,9 +16,9 @@ import ( ) const ( - defaultGroupOrder int64 = 0 - minGroupOrder int64 = -1000 - maxGroupOder int64 = 1000 + defaultGroupOrder int32 = 0 + minGroupOrder int32 = -1000 + maxGroupOder int32 = 1000 maxGroupNameLength int = 63 ) @@ -264,7 +264,7 @@ func (m *defaultGroupLoader) containsGroupFinalizer(groupID GroupID, finalizer s type groupMemberWithOrder struct { member ClassifiedIngress - order int64 + order int32 } // sortGroupMembers will sort Ingresses within Ingress group in ascending order. @@ -280,7 +280,7 @@ func (m *defaultGroupLoader) sortGroupMembers(members []ClassifiedIngress) ([]Cl groupMemberWithOrderList := make([]groupMemberWithOrder, 0, len(members)) for _, member := range members { var order = defaultGroupOrder - exists, err := m.annotationParser.ParseInt64Annotation(annotations.IngressSuffixGroupOrder, &order, member.Ing.Annotations) + exists, err := m.annotationParser.ParseInt32Annotation(annotations.IngressSuffixGroupOrder, &order, member.Ing.Annotations) if err != nil { return nil, errors.Wrapf(err, "failed to load Ingress group order for ingress: %v", k8s.NamespacedName(member.Ing)) } diff --git a/pkg/ingress/group_loader_test.go b/pkg/ingress/group_loader_test.go index d1d051dd97..6bef1b4873 100644 --- a/pkg/ingress/group_loader_test.go +++ b/pkg/ingress/group_loader_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" "github.com/pkg/errors" diff --git a/pkg/ingress/model_build_actions.go b/pkg/ingress/model_build_actions.go index e93d67ad4d..e2e883dbc3 100644 --- a/pkg/ingress/model_build_actions.go +++ b/pkg/ingress/model_build_actions.go @@ -3,7 +3,7 @@ package ingress import ( "context" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" @@ -108,7 +108,7 @@ func (t *defaultModelBuildTask) buildForwardAction(ctx context.Context, ing Clas } else { svcKey := types.NamespacedName{ Namespace: ing.Ing.Namespace, - Name: awssdk.StringValue(tgt.ServiceName), + Name: awssdk.ToString(tgt.ServiceName), } svc := t.backendServices[svcKey] tg, err := t.buildTargetGroup(ctx, ing, svc, *tgt.ServicePort) @@ -151,7 +151,7 @@ func (t *defaultModelBuildTask) buildAuthenticateCognitoAction(_ context.Context UserPoolClientID: authCfg.IDPConfigCognito.UserPoolClientID, UserPoolDomain: authCfg.IDPConfigCognito.UserPoolDomain, AuthenticationRequestExtraParams: authCfg.IDPConfigCognito.AuthenticationRequestExtraParams, - OnUnauthenticatedRequest: &onUnauthenticatedRequest, + OnUnauthenticatedRequest: onUnauthenticatedRequest, Scope: &authCfg.Scope, SessionCookieName: &authCfg.SessionCookieName, SessionTimeout: &authCfg.SessionTimeout, @@ -198,7 +198,7 @@ func (t *defaultModelBuildTask) buildAuthenticateOIDCAction(ctx context.Context, ClientID: clientID, ClientSecret: clientSecret, AuthenticationRequestExtraParams: authCfg.IDPConfigOIDC.AuthenticationRequestExtraParams, - OnUnauthenticatedRequest: &onUnauthenticatedRequest, + OnUnauthenticatedRequest: onUnauthenticatedRequest, Scope: &authCfg.Scope, SessionCookieName: &authCfg.SessionCookieName, SessionTimeout: &authCfg.SessionTimeout, diff --git a/pkg/ingress/model_build_actions_test.go b/pkg/ingress/model_build_actions_test.go index 9582c3a2a7..91a3e51733 100644 --- a/pkg/ingress/model_build_actions_test.go +++ b/pkg/ingress/model_build_actions_test.go @@ -2,7 +2,7 @@ package ingress import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" @@ -78,7 +78,7 @@ func Test_defaultModelBuildTask_buildAuthenticateOIDCAction(t *testing.T) { AuthenticationRequestExtraParams: map[string]string{ "key1": "value1", }, - OnUnauthenticatedRequest: &authBehaviorAuthenticate, + OnUnauthenticatedRequest: authBehaviorAuthenticate, Scope: awssdk.String("email"), SessionCookieName: awssdk.String("my-session-cookie"), SessionTimeout: awssdk.Int64(65536), @@ -133,7 +133,7 @@ func Test_defaultModelBuildTask_buildAuthenticateOIDCAction(t *testing.T) { AuthenticationRequestExtraParams: map[string]string{ "key1": "value1", }, - OnUnauthenticatedRequest: &authBehaviorAuthenticate, + OnUnauthenticatedRequest: authBehaviorAuthenticate, Scope: awssdk.String("email"), SessionCookieName: awssdk.String("my-session-cookie"), SessionTimeout: awssdk.Int64(65536), diff --git a/pkg/ingress/model_build_listener.go b/pkg/ingress/model_build_listener.go index 8921765850..73605aef56 100644 --- a/pkg/ingress/model_build_listener.go +++ b/pkg/ingress/model_build_listener.go @@ -4,12 +4,12 @@ import ( "context" "encoding/json" "fmt" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "k8s.io/utils/strings/slices" "net" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" networking "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/types" @@ -21,7 +21,7 @@ import ( elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" ) -func (t *defaultModelBuildTask) buildListener(ctx context.Context, lbARN core.StringToken, port int64, config listenPortConfig, ingList []ClassifiedIngress) (*elbv2model.Listener, error) { +func (t *defaultModelBuildTask) buildListener(ctx context.Context, lbARN core.StringToken, port int32, config listenPortConfig, ingList []ClassifiedIngress) (*elbv2model.Listener, error) { lsSpec, err := t.buildListenerSpec(ctx, lbARN, port, config, ingList) if err != nil { return nil, err @@ -31,7 +31,7 @@ func (t *defaultModelBuildTask) buildListener(ctx context.Context, lbARN core.St return ls, nil } -func (t *defaultModelBuildTask) buildListenerSpec(ctx context.Context, lbARN core.StringToken, port int64, config listenPortConfig, ingList []ClassifiedIngress) (elbv2model.ListenerSpec, error) { +func (t *defaultModelBuildTask) buildListenerSpec(ctx context.Context, lbARN core.StringToken, port int32, config listenPortConfig, ingList []ClassifiedIngress) (elbv2model.ListenerSpec, error) { defaultActions, err := t.buildListenerDefaultActions(ctx, config.protocol, ingList) if err != nil { return elbv2model.ListenerSpec{}, err @@ -109,7 +109,7 @@ type listenPortConfig struct { mutualAuthentication *elbv2model.MutualAuthenticationAttributes } -func (t *defaultModelBuildTask) computeIngressListenPortConfigByPort(ctx context.Context, ing *ClassifiedIngress) (map[int64]listenPortConfig, error) { +func (t *defaultModelBuildTask) computeIngressListenPortConfigByPort(ctx context.Context, ing *ClassifiedIngress) (map[int32]listenPortConfig, error) { explicitTLSCertARNs := t.computeIngressExplicitTLSCertARNs(ctx, ing) explicitSSLPolicy := t.computeIngressExplicitSSLPolicy(ctx, ing) var prefixListIDs []string @@ -143,7 +143,7 @@ func (t *defaultModelBuildTask) computeIngressListenPortConfigByPort(ctx context } } - listenPortConfigByPort := make(map[int64]listenPortConfig, len(listenPorts)) + listenPortConfigByPort := make(map[int32]listenPortConfig, len(listenPorts)) for port, protocol := range listenPorts { cfg := listenPortConfig{ protocol: protocol, @@ -188,16 +188,16 @@ func (t *defaultModelBuildTask) computeIngressInferredTLSCertARNs(ctx context.Co return t.certDiscovery.Discover(ctx, hosts.List()) } -func (t *defaultModelBuildTask) computeIngressListenPorts(_ context.Context, ing *networking.Ingress, preferTLS bool) (map[int64]elbv2model.Protocol, error) { +func (t *defaultModelBuildTask) computeIngressListenPorts(_ context.Context, ing *networking.Ingress, preferTLS bool) (map[int32]elbv2model.Protocol, error) { rawListenPorts := "" if exists := t.annotationParser.ParseStringAnnotation(annotations.IngressSuffixListenPorts, &rawListenPorts, ing.Annotations); !exists { if preferTLS { - return map[int64]elbv2model.Protocol{443: elbv2model.ProtocolHTTPS}, nil + return map[int32]elbv2model.Protocol{443: elbv2model.ProtocolHTTPS}, nil } - return map[int64]elbv2model.Protocol{80: elbv2model.ProtocolHTTP}, nil + return map[int32]elbv2model.Protocol{80: elbv2model.ProtocolHTTP}, nil } - var entries []map[string]int64 + var entries []map[string]int32 if err := json.Unmarshal([]byte(rawListenPorts), &entries); err != nil { return nil, errors.Wrapf(err, "failed to parse listen-ports configuration: `%s`", rawListenPorts) } @@ -205,7 +205,7 @@ func (t *defaultModelBuildTask) computeIngressListenPorts(_ context.Context, ing return nil, errors.Errorf("empty listen-ports configuration: `%s`", rawListenPorts) } - portAndProtocols := make(map[int64]elbv2model.Protocol, len(entries)) + portAndProtocols := make(map[int32]elbv2model.Protocol, len(entries)) for _, entry := range entries { for protocol, port := range entry { // Verify port value is valid for ALB: [1, 65535] @@ -265,13 +265,13 @@ func (t *defaultModelBuildTask) computeIngressExplicitSSLPolicy(_ context.Contex } type MutualAuthenticationConfig struct { - Port int64 `json:"port"` + Port int32 `json:"port"` Mode string `json:"mode"` TrustStore *string `json:"trustStore,omitempty"` IgnoreClientCertificateExpiry *bool `json:"ignoreClientCertificateExpiry,omitempty"` } -func (t *defaultModelBuildTask) computeIngressMutualAuthentication(ctx context.Context, ing *ClassifiedIngress) (map[int64]*elbv2model.MutualAuthenticationAttributes, error) { +func (t *defaultModelBuildTask) computeIngressMutualAuthentication(ctx context.Context, ing *ClassifiedIngress) (map[int32]*elbv2model.MutualAuthenticationAttributes, error) { var rawMtlsConfigString string if exists := t.annotationParser.ParseStringAnnotation(annotations.IngressSuffixMutualAuthentication, &rawMtlsConfigString, ing.Ing.Annotations); !exists { return nil, nil @@ -297,13 +297,13 @@ func (t *defaultModelBuildTask) computeIngressMutualAuthentication(ctx context.C return parsedPortAndMtlsAttributes, nil } -func (t *defaultModelBuildTask) parseMtlsConfigEntries(_ context.Context, entries []MutualAuthenticationConfig) (map[int64]*elbv2model.MutualAuthenticationAttributes, error) { - portAndMtlsAttributes := make(map[int64]*elbv2model.MutualAuthenticationAttributes, len(entries)) +func (t *defaultModelBuildTask) parseMtlsConfigEntries(_ context.Context, entries []MutualAuthenticationConfig) (map[int32]*elbv2model.MutualAuthenticationAttributes, error) { + portAndMtlsAttributes := make(map[int32]*elbv2model.MutualAuthenticationAttributes, len(entries)) for _, mutualAuthenticationConfig := range entries { port := mutualAuthenticationConfig.Port mode := mutualAuthenticationConfig.Mode - truststoreNameOrArn := awssdk.StringValue(mutualAuthenticationConfig.TrustStore) + truststoreNameOrArn := awssdk.ToString(mutualAuthenticationConfig.TrustStore) ignoreClientCert := mutualAuthenticationConfig.IgnoreClientCertificateExpiry err := t.validateMutualAuthenticationConfig(port, mode, truststoreNameOrArn, ignoreClientCert) @@ -319,7 +319,7 @@ func (t *defaultModelBuildTask) parseMtlsConfigEntries(_ context.Context, entrie return portAndMtlsAttributes, nil } -func (t *defaultModelBuildTask) validateMutualAuthenticationConfig(port int64, mode string, truststoreNameOrArn string, ignoreClientCert *bool) error { +func (t *defaultModelBuildTask) validateMutualAuthenticationConfig(port int32, mode string, truststoreNameOrArn string, ignoreClientCert *bool) error { // Verify port value is valid for ALB: [1, 65535] if port < 1 || port > 65535 { return errors.Errorf("listen port must be within [1, 65535]: %v", port) @@ -349,13 +349,13 @@ func (t *defaultModelBuildTask) validateMutualAuthenticationConfig(port int64, m return nil } -func (t *defaultModelBuildTask) parseMtlsAttributesForTrustStoreNames(ctx context.Context, portAndMtlsAttributes map[int64]*elbv2model.MutualAuthenticationAttributes) (map[int64]*elbv2model.MutualAuthenticationAttributes, error) { +func (t *defaultModelBuildTask) parseMtlsAttributesForTrustStoreNames(ctx context.Context, portAndMtlsAttributes map[int32]*elbv2model.MutualAuthenticationAttributes) (map[int32]*elbv2model.MutualAuthenticationAttributes, error) { var trustStoreNames []string - trustStoreNameAndPortMap := make(map[string][]int64) + trustStoreNameAndPortMap := make(map[string][]int32) for port, attributes := range portAndMtlsAttributes { mode := attributes.Mode - truststoreNameOrArn := awssdk.StringValue(attributes.TrustStoreArn) + truststoreNameOrArn := awssdk.ToString(attributes.TrustStoreArn) if mode == string(elbv2model.MutualAuthenticationVerifyMode) && !strings.HasPrefix(truststoreNameOrArn, "arn:") { trustStoreNameAndPortMap[truststoreNameOrArn] = append(trustStoreNameAndPortMap[truststoreNameOrArn], port) } @@ -372,7 +372,7 @@ func (t *defaultModelBuildTask) parseMtlsAttributesForTrustStoreNames(ctx contex for name, ports := range trustStoreNameAndPortMap { for _, port := range ports { attributes := portAndMtlsAttributes[port] - if awssdk.StringValue(attributes.TrustStoreArn) != "" { + if awssdk.ToString(attributes.TrustStoreArn) != "" { attributes.TrustStoreArn = tsNameAndArnMap[name] } portAndMtlsAttributes[port] = attributes @@ -385,7 +385,7 @@ func (t *defaultModelBuildTask) parseMtlsAttributesForTrustStoreNames(ctx contex func (t *defaultModelBuildTask) fetchTrustStoreArnFromName(ctx context.Context, trustStoreNames []string) (map[string]*string, error) { tsNameAndArnMap := make(map[string]*string, len(trustStoreNames)) req := &elbv2sdk.DescribeTrustStoresInput{ - Names: awssdk.StringSlice(trustStoreNames), + Names: trustStoreNames, } trustStores, err := t.elbv2Client.DescribeTrustStoresWithContext(ctx, req) if err != nil { @@ -396,7 +396,7 @@ func (t *defaultModelBuildTask) fetchTrustStoreArnFromName(ctx context.Context, } for _, tsName := range trustStoreNames { for _, ts := range trustStores.TrustStores { - if tsName == awssdk.StringValue(ts.Name) { + if tsName == awssdk.ToString(ts.Name) { tsNameAndArnMap[tsName] = ts.TrustStoreArn } } diff --git a/pkg/ingress/model_build_listener_rules.go b/pkg/ingress/model_build_listener_rules.go index aa962eb581..dcdc0e1011 100644 --- a/pkg/ingress/model_build_listener_rules.go +++ b/pkg/ingress/model_build_listener_rules.go @@ -14,7 +14,7 @@ import ( elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" ) -func (t *defaultModelBuildTask) buildListenerRules(ctx context.Context, lsARN core.StringToken, port int64, protocol elbv2model.Protocol, ingList []ClassifiedIngress) error { +func (t *defaultModelBuildTask) buildListenerRules(ctx context.Context, lsARN core.StringToken, port int32, protocol elbv2model.Protocol, ingList []ClassifiedIngress) error { if t.sslRedirectConfig != nil && protocol == elbv2model.ProtocolHTTP { return nil } @@ -61,7 +61,7 @@ func (t *defaultModelBuildTask) buildListenerRules(ctx context.Context, lsARN co return err } - priority := int64(1) + priority := int32(1) for _, rule := range optimizedRules { ruleResID := fmt.Sprintf("%v:%v", port, priority) _ = elbv2model.NewListenerRule(t.stack, ruleResID, elbv2model.ListenerRuleSpec{ diff --git a/pkg/ingress/model_build_listener_rules_test.go b/pkg/ingress/model_build_listener_rules_test.go index e9a3158ec2..bad0ccc867 100644 --- a/pkg/ingress/model_build_listener_rules_test.go +++ b/pkg/ingress/model_build_listener_rules_test.go @@ -1,7 +1,7 @@ package ingress import ( - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" "github.com/stretchr/testify/assert" networking "k8s.io/api/networking/v1" diff --git a/pkg/ingress/model_build_listener_test.go b/pkg/ingress/model_build_listener_test.go index 223ee2d406..d52b4e9b24 100644 --- a/pkg/ingress/model_build_listener_test.go +++ b/pkg/ingress/model_build_listener_test.go @@ -15,7 +15,7 @@ func Test_computeIngressListenPortConfigByPort_MutualAuthentication(t *testing.T ingGroup Group } type WantStruct struct { - port int64 + port int32 mutualAuth *elbv2.MutualAuthenticationAttributes } diff --git a/pkg/ingress/model_build_load_balancer.go b/pkg/ingress/model_build_load_balancer.go index 62bc340475..fac48df9a9 100644 --- a/pkg/ingress/model_build_load_balancer.go +++ b/pkg/ingress/model_build_load_balancer.go @@ -5,10 +5,10 @@ import ( "crypto/sha256" "encoding/hex" "fmt" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "regexp" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/google/go-cmp/cmp" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/sets" @@ -26,10 +26,10 @@ import ( const ( resourceIDLoadBalancer = "LoadBalancer" - minimalAvailableIPAddressCount = int64(8) + minimalAvailableIPAddressCount = int32(8) ) -func (t *defaultModelBuildTask) buildLoadBalancer(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig) (*elbv2model.LoadBalancer, error) { +func (t *defaultModelBuildTask) buildLoadBalancer(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig) (*elbv2model.LoadBalancer, error) { lbSpec, err := t.buildLoadBalancerSpec(ctx, listenPortConfigByPort) if err != nil { return nil, err @@ -39,7 +39,7 @@ func (t *defaultModelBuildTask) buildLoadBalancer(ctx context.Context, listenPor return lb, nil } -func (t *defaultModelBuildTask) buildLoadBalancerSpec(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig) (elbv2model.LoadBalancerSpec, error) { +func (t *defaultModelBuildTask) buildLoadBalancerSpec(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig) (elbv2model.LoadBalancerSpec, error) { scheme, err := t.buildLoadBalancerScheme(ctx) if err != nil { return elbv2model.LoadBalancerSpec{}, err @@ -75,8 +75,8 @@ func (t *defaultModelBuildTask) buildLoadBalancerSpec(ctx context.Context, liste return elbv2model.LoadBalancerSpec{ Name: name, Type: elbv2model.LoadBalancerTypeApplication, - Scheme: &scheme, - IPAddressType: &ipAddressType, + Scheme: scheme, + IPAddressType: ipAddressType, SubnetMappings: subnetMappings, SecurityGroups: securityGroups, CustomerOwnedIPv4Pool: coIPv4Pool, @@ -250,7 +250,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(ctx context.Cont return nil, err } - if len(sdkLBs) == 0 || (string(scheme) != awssdk.StringValue(sdkLBs[0].LoadBalancer.Scheme)) { + if len(sdkLBs) == 0 || (string(scheme) != string(sdkLBs[0].LoadBalancer.Scheme)) { chosenSubnets, err := t.subnetsResolver.ResolveViaDiscovery(ctx, networking.WithSubnetsResolveLBType(elbv2model.LoadBalancerTypeApplication), networking.WithSubnetsResolveLBScheme(scheme), @@ -266,13 +266,13 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(ctx context.Cont availabilityZones := sdkLBs[0].LoadBalancer.AvailabilityZones subnetIDs := make([]string, 0, len(availabilityZones)) for _, availabilityZone := range availabilityZones { - subnetID := awssdk.StringValue(availabilityZone.SubnetId) + subnetID := awssdk.ToString(availabilityZone.SubnetId) subnetIDs = append(subnetIDs, subnetID) } return buildLoadBalancerSubnetMappingsWithSubnetIDs(subnetIDs), nil } -func (t *defaultModelBuildTask) buildLoadBalancerSecurityGroups(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig, ipAddressType elbv2model.IPAddressType) ([]core.StringToken, error) { +func (t *defaultModelBuildTask) buildLoadBalancerSecurityGroups(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig, ipAddressType elbv2model.IPAddressType) ([]core.StringToken, error) { sgNameOrIDsViaAnnotation, err := t.buildFrontendSGNameOrIDsFromAnnotation(ctx) if err != nil { return nil, err @@ -395,11 +395,11 @@ func (t *defaultModelBuildTask) buildLoadBalancerTags(_ context.Context) (map[st return algorithm.MergeStringMap(t.defaultTags, ingGroupTags), nil } -func buildLoadBalancerSubnetMappingsWithSubnets(subnets []*ec2sdk.Subnet) []elbv2model.SubnetMapping { +func buildLoadBalancerSubnetMappingsWithSubnets(subnets []ec2types.Subnet) []elbv2model.SubnetMapping { subnetMappings := make([]elbv2model.SubnetMapping, 0, len(subnets)) for _, subnet := range subnets { subnetMappings = append(subnetMappings, elbv2model.SubnetMapping{ - SubnetID: awssdk.StringValue(subnet.SubnetId), + SubnetID: awssdk.ToString(subnet.SubnetId), }) } return subnetMappings diff --git a/pkg/ingress/model_build_load_balancer_test.go b/pkg/ingress/model_build_load_balancer_test.go index 905cd7c33d..8b1c43a2dc 100644 --- a/pkg/ingress/model_build_load_balancer_test.go +++ b/pkg/ingress/model_build_load_balancer_test.go @@ -4,11 +4,12 @@ import ( "context" "errors" "fmt" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "strings" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" @@ -683,15 +684,15 @@ func Test_defaultModelBuildTask_buildLoadBalancerName(t *testing.T) { } var ( - subnet1 = &ec2.Subnet{ + subnet1 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("az1"), VpcId: awssdk.String("vpc-1"), } - subnet2 = &ec2.Subnet{ + subnet2 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-2"), AvailabilityZone: awssdk.String("az2"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("namedsubnet"), @@ -699,15 +700,15 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet3 = &ec2.Subnet{ + subnet3 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-3"), AvailabilityZone: awssdk.String("az3"), VpcId: awssdk.String("vpc-1"), } - subnet4 = &ec2.Subnet{ + subnet4 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-4"), AvailabilityZone: awssdk.String("az4"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("othername"), @@ -715,10 +716,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet5 = &ec2.Subnet{ + subnet5 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-5"), AvailabilityZone: awssdk.String("az5"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("namedsubnet"), @@ -726,10 +727,10 @@ var ( }, VpcId: awssdk.String("vpc-2"), } - subnet6 = &ec2.Subnet{ + subnet6 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-6"), AvailabilityZone: awssdk.String("az6"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("subnet-1"), @@ -737,10 +738,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet7 = &ec2.Subnet{ + subnet7 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-7"), AvailabilityZone: awssdk.String("az7"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("subnet-1"), @@ -751,10 +752,10 @@ var ( }}, VpcId: awssdk.String("vpc-1"), } - subnet8 = &ec2.Subnet{ + subnet8 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-8"), AvailabilityZone: awssdk.String("az8"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("alb"), Value: awssdk.String("test"), @@ -762,10 +763,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet9 = &ec2.Subnet{ + subnet9 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-9"), AvailabilityZone: awssdk.String("az9"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("Name"), Value: awssdk.String("subnet-12"), @@ -780,10 +781,10 @@ var ( }}, VpcId: awssdk.String("vpc-1"), } - subnet10 = &ec2.Subnet{ + subnet10 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-10"), AvailabilityZone: awssdk.String("az10"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("alb"), Value: awssdk.String("testing"), @@ -795,10 +796,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet11 = &ec2.Subnet{ + subnet11 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-11"), AvailabilityZone: awssdk.String("az11"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("tagtest"), Value: awssdk.String("1"), @@ -810,10 +811,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet12 = &ec2.Subnet{ + subnet12 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-12"), AvailabilityZone: awssdk.String("az12"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("tagtest"), Value: awssdk.String("1"), @@ -821,10 +822,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet13 = &ec2.Subnet{ + subnet13 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-13"), AvailabilityZone: awssdk.String("az13"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("tagtest"), Value: awssdk.String("1"), @@ -836,10 +837,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet14 = &ec2.Subnet{ + subnet14 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-14"), AvailabilityZone: awssdk.String("az14"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("tagtest2"), Value: awssdk.String("1"), @@ -847,10 +848,10 @@ var ( }, VpcId: awssdk.String("vpc-1"), } - subnet15 = &ec2.Subnet{ + subnet15 = ec2types.Subnet{ SubnetId: awssdk.String("subnet-15"), AvailabilityZone: awssdk.String("az14"), - Tags: []*ec2.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("tagtest2"), Value: awssdk.String("1"), @@ -864,8 +865,8 @@ var ( } ) -func stubDescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]*ec2.Subnet, error) { - subnets := []*ec2.Subnet{ +func stubDescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsInput) ([]ec2types.Subnet, error) { + subnets := []ec2types.Subnet{ subnet1, subnet2, subnet3, @@ -883,10 +884,10 @@ func stubDescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsIn subnet15, } if input.SubnetIds != nil { - var filtered []*ec2.Subnet + var filtered []ec2types.Subnet for _, subnet := range subnets { for _, id := range input.SubnetIds { - if awssdk.StringValue(subnet.SubnetId) == awssdk.StringValue(id) { + if awssdk.ToString(subnet.SubnetId) == id { filtered = append(filtered, subnet) continue } @@ -895,30 +896,30 @@ func stubDescribeSubnetsAsList(ctx context.Context, input *ec2.DescribeSubnetsIn subnets = filtered } if input.Filters != nil { - var filtered []*ec2.Subnet + var filtered []ec2types.Subnet subnetLoop: for _, subnet := range subnets { for _, filter := range input.Filters { eligible := false - if awssdk.StringValue(filter.Name) == "vpc-id" { + if awssdk.ToString(filter.Name) == "vpc-id" { for _, name := range filter.Values { - if awssdk.StringValue(subnet.VpcId) == awssdk.StringValue(name) { + if awssdk.ToString(subnet.VpcId) == name { eligible = true continue } } - } else if strings.HasPrefix(awssdk.StringValue(filter.Name), "tag:") { - key := strings.TrimPrefix(awssdk.StringValue(filter.Name), "tag:") + } else if strings.HasPrefix(awssdk.ToString(filter.Name), "tag:") { + key := strings.TrimPrefix(awssdk.ToString(filter.Name), "tag:") for _, value := range filter.Values { for _, tag := range subnet.Tags { - if awssdk.StringValue(tag.Key) == key && awssdk.StringValue(tag.Value) == awssdk.StringValue(value) { + if awssdk.ToString(tag.Key) == key && awssdk.ToString(tag.Value) == value { eligible = true continue } } } } else { - return nil, fmt.Errorf("unexpected filter %q", awssdk.StringValue(filter.Name)) + return nil, fmt.Errorf("unexpected filter %q", awssdk.ToString(filter.Name)) } if !eligible { continue subnetLoop @@ -1257,10 +1258,10 @@ func Test_defaultModelBuildTask_buildLoadBalancerSubnets(t *testing.T) { azInfoProvider := networking2.NewMockAZInfoProvider(ctrl) azInfoProvider.EXPECT().FetchAZInfos(gomock.Any(), gomock.Any()). - DoAndReturn(func(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2.AvailabilityZone, error) { - ret := make(map[string]ec2.AvailabilityZone, len(availabilityZoneIDs)) + DoAndReturn(func(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2types.AvailabilityZone, error) { + ret := make(map[string]ec2types.AvailabilityZone, len(availabilityZoneIDs)) for _, id := range availabilityZoneIDs { - ret[id] = ec2.AvailabilityZone{ZoneType: awssdk.String("availability-zone")} + ret[id] = ec2types.AvailabilityZone{ZoneType: awssdk.String("availability-zone")} } return ret, nil }).AnyTimes() diff --git a/pkg/ingress/model_build_managed_sg.go b/pkg/ingress/model_build_managed_sg.go index e048fc793f..4a551ab908 100644 --- a/pkg/ingress/model_build_managed_sg.go +++ b/pkg/ingress/model_build_managed_sg.go @@ -7,7 +7,7 @@ import ( "fmt" "regexp" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" ec2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/ec2" elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" @@ -17,7 +17,7 @@ const ( resourceIDManagedSecurityGroup = "ManagedLBSecurityGroup" ) -func (t *defaultModelBuildTask) buildManagedSecurityGroup(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig, ipAddressType elbv2model.IPAddressType) (*ec2model.SecurityGroup, error) { +func (t *defaultModelBuildTask) buildManagedSecurityGroup(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig, ipAddressType elbv2model.IPAddressType) (*ec2model.SecurityGroup, error) { sgSpec, err := t.buildManagedSecurityGroupSpec(ctx, listenPortConfigByPort, ipAddressType) if err != nil { return nil, err @@ -27,7 +27,7 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroup(ctx context.Context, l return sg, nil } -func (t *defaultModelBuildTask) buildManagedSecurityGroupSpec(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig, ipAddressType elbv2model.IPAddressType) (ec2model.SecurityGroupSpec, error) { +func (t *defaultModelBuildTask) buildManagedSecurityGroupSpec(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig, ipAddressType elbv2model.IPAddressType) (ec2model.SecurityGroupSpec, error) { name := t.buildManagedSecurityGroupName(ctx) tags, err := t.buildManagedSecurityGroupTags(ctx) if err != nil { @@ -68,14 +68,14 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupTags(_ context.Context) return algorithm.MergeStringMap(t.defaultTags, ingGroupTags), nil } -func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(_ context.Context, listenPortConfigByPort map[int64]listenPortConfig, ipAddressType elbv2model.IPAddressType) []ec2model.IPPermission { +func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(_ context.Context, listenPortConfigByPort map[int32]listenPortConfig, ipAddressType elbv2model.IPAddressType) []ec2model.IPPermission { var permissions []ec2model.IPPermission for port, cfg := range listenPortConfigByPort { for _, cidr := range cfg.inboundCIDRv4s { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: "tcp", - FromPort: awssdk.Int64(port), - ToPort: awssdk.Int64(port), + FromPort: awssdk.Int32(port), + ToPort: awssdk.Int32(port), IPRanges: []ec2model.IPRange{ { CIDRIP: cidr, @@ -87,8 +87,8 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(_ co for _, cidr := range cfg.inboundCIDRv6s { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: "tcp", - FromPort: awssdk.Int64(port), - ToPort: awssdk.Int64(port), + FromPort: awssdk.Int32(port), + ToPort: awssdk.Int32(port), IPv6Range: []ec2model.IPv6Range{ { CIDRIPv6: cidr, @@ -100,8 +100,8 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(_ co for _, prefixID := range cfg.prefixLists { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: "tcp", - FromPort: awssdk.Int64(port), - ToPort: awssdk.Int64(port), + FromPort: awssdk.Int32(port), + ToPort: awssdk.Int32(port), PrefixLists: []ec2model.PrefixList{ { ListID: prefixID, diff --git a/pkg/ingress/model_build_target_group.go b/pkg/ingress/model_build_target_group.go index 2c4bd905b5..38b636df60 100644 --- a/pkg/ingress/model_build_target_group.go +++ b/pkg/ingress/model_build_target_group.go @@ -5,6 +5,7 @@ import ( "crypto/sha256" "encoding/hex" "fmt" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "regexp" "strconv" @@ -76,7 +77,7 @@ func (t *defaultModelBuildTask) buildTargetGroupBindingSpec(ctx context.Context, }, Networking: tgbNetworking, NodeSelector: nodeSelector, - IPAddressType: (*elbv2api.TargetGroupIPAddressType)(tg.Spec.IPAddressType), + IPAddressType: elbv2api.TargetGroupIPAddressType(tg.Spec.IPAddressType), VpcID: t.vpcID, }, }, @@ -174,10 +175,10 @@ func (t *defaultModelBuildTask) buildTargetGroupSpec(ctx context.Context, return elbv2model.TargetGroupSpec{ Name: name, TargetType: targetType, - Port: tgPort, + Port: awssdk.Int32(tgPort), Protocol: tgProtocol, ProtocolVersion: &tgProtocolVersion, - IPAddressType: &ipAddressType, + IPAddressType: ipAddressType, HealthCheckConfig: &healthCheckConfig, TargetGroupAttributes: tgAttributes, Tags: tags, @@ -188,7 +189,7 @@ var invalidTargetGroupNamePattern = regexp.MustCompile("[[:^alnum:]]") // buildTargetGroupName will calculate the targetGroup's name. func (t *defaultModelBuildTask) buildTargetGroupName(_ context.Context, - ingKey types.NamespacedName, svc *corev1.Service, port intstr.IntOrString, tgPort int64, + ingKey types.NamespacedName, svc *corev1.Service, port intstr.IntOrString, tgPort int32, targetType elbv2model.TargetType, tgProtocol elbv2model.Protocol, tgProtocolVersion elbv2model.ProtocolVersion) string { uuidHash := sha256.New() _, _ = uuidHash.Write([]byte(t.clusterName)) @@ -233,7 +234,7 @@ func (t *defaultModelBuildTask) buildTargetGroupIPAddressType(_ context.Context, } } if ipv6Configured { - if !isIPv6Supported(*t.loadBalancer.Spec.IPAddressType) { + if !isIPv6Supported(t.loadBalancer.Spec.IPAddressType) { return "", errors.New("unsupported IPv6 configuration, lb not dual-stack") } return elbv2model.TargetGroupIPAddressTypeIPv6, nil @@ -244,12 +245,12 @@ func (t *defaultModelBuildTask) buildTargetGroupIPAddressType(_ context.Context, // buildTargetGroupPort constructs the TargetGroup's port. // Note: TargetGroup's port is not in the data path as we always register targets with port specified. // so this settings don't really matter to our controller, and we do our best to use the most appropriate port as targetGroup's port to avoid UX confusing. -func (t *defaultModelBuildTask) buildTargetGroupPort(_ context.Context, targetType elbv2model.TargetType, svcPort corev1.ServicePort) int64 { +func (t *defaultModelBuildTask) buildTargetGroupPort(_ context.Context, targetType elbv2model.TargetType, svcPort corev1.ServicePort) int32 { if targetType == elbv2model.TargetTypeInstance { - return int64(svcPort.NodePort) + return svcPort.NodePort } if svcPort.TargetPort.Type == intstr.Int { - return int64(svcPort.TargetPort.IntValue()) + return int32(svcPort.TargetPort.IntValue()) } // when a literal targetPort is used, we just use a fixed 1 here as this setting is not in the data path. @@ -314,13 +315,13 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckConfig(ctx context.Co } return elbv2model.TargetGroupHealthCheckConfig{ Port: &healthCheckPort, - Protocol: &healthCheckProtocol, + Protocol: healthCheckProtocol, Path: &healthCheckPath, Matcher: &healthCheckMatcher, - IntervalSeconds: &healthCheckIntervalSeconds, - TimeoutSeconds: &healthCheckTimeoutSeconds, - HealthyThresholdCount: &healthCheckHealthyThresholdCount, - UnhealthyThresholdCount: &healthCheckUnhealthyThresholdCount, + IntervalSeconds: awssdk.Int32(int32(healthCheckIntervalSeconds)), + TimeoutSeconds: awssdk.Int32(int32(healthCheckTimeoutSeconds)), + HealthyThresholdCount: awssdk.Int32(int32(healthCheckHealthyThresholdCount)), + UnhealthyThresholdCount: awssdk.Int32(healthCheckUnhealthyThresholdCount), }, nil } @@ -395,36 +396,36 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckMatcher(_ context.Con } } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckIntervalSeconds(_ context.Context, svcAndIngAnnotations map[string]string) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckIntervalSeconds(_ context.Context, svcAndIngAnnotations map[string]string) (int32, error) { rawHealthCheckIntervalSeconds := t.defaultHealthCheckIntervalSeconds - if _, err := t.annotationParser.ParseInt64Annotation(annotations.IngressSuffixHealthCheckIntervalSeconds, + if _, err := t.annotationParser.ParseInt32Annotation(annotations.IngressSuffixHealthCheckIntervalSeconds, &rawHealthCheckIntervalSeconds, svcAndIngAnnotations); err != nil { return 0, err } return rawHealthCheckIntervalSeconds, nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckTimeoutSeconds(_ context.Context, svcAndIngAnnotations map[string]string) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckTimeoutSeconds(_ context.Context, svcAndIngAnnotations map[string]string) (int32, error) { rawHealthCheckTimeoutSeconds := t.defaultHealthCheckTimeoutSeconds - if _, err := t.annotationParser.ParseInt64Annotation(annotations.IngressSuffixHealthCheckTimeoutSeconds, + if _, err := t.annotationParser.ParseInt32Annotation(annotations.IngressSuffixHealthCheckTimeoutSeconds, &rawHealthCheckTimeoutSeconds, svcAndIngAnnotations); err != nil { return 0, err } return rawHealthCheckTimeoutSeconds, nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckHealthyThresholdCount(_ context.Context, svcAndIngAnnotations map[string]string) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckHealthyThresholdCount(_ context.Context, svcAndIngAnnotations map[string]string) (int32, error) { rawHealthCheckHealthyThresholdCount := t.defaultHealthCheckHealthyThresholdCount - if _, err := t.annotationParser.ParseInt64Annotation(annotations.IngressSuffixHealthyThresholdCount, + if _, err := t.annotationParser.ParseInt32Annotation(annotations.IngressSuffixHealthyThresholdCount, &rawHealthCheckHealthyThresholdCount, svcAndIngAnnotations); err != nil { return 0, err } return rawHealthCheckHealthyThresholdCount, nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckUnhealthyThresholdCount(_ context.Context, svcAndIngAnnotations map[string]string) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckUnhealthyThresholdCount(_ context.Context, svcAndIngAnnotations map[string]string) (int32, error) { rawHealthCheckUnhealthyThresholdCount := t.defaultHealthCheckUnhealthyThresholdCount - if _, err := t.annotationParser.ParseInt64Annotation(annotations.IngressSuffixUnhealthyThresholdCount, + if _, err := t.annotationParser.ParseInt32Annotation(annotations.IngressSuffixUnhealthyThresholdCount, &rawHealthCheckUnhealthyThresholdCount, svcAndIngAnnotations); err != nil { return 0, err } diff --git a/pkg/ingress/model_build_target_group_test.go b/pkg/ingress/model_build_target_group_test.go index 74f7b7c70c..4bcf05d6e8 100644 --- a/pkg/ingress/model_build_target_group_test.go +++ b/pkg/ingress/model_build_target_group_test.go @@ -2,7 +2,7 @@ package ingress import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" @@ -21,7 +21,7 @@ func Test_defaultModelBuildTask_buildTargetGroupName(t *testing.T) { ingKey types.NamespacedName svc *corev1.Service port intstr.IntOrString - tgPort int64 + tgPort int32 targetType elbv2model.TargetType tgProtocol elbv2model.Protocol tgProtocolVersion elbv2model.ProtocolVersion @@ -144,7 +144,7 @@ func Test_defaultModelBuildTask_buildTargetGroupPort(t *testing.T) { tests := []struct { name string args args - want int64 + want int32 }{ { name: "instance targetGroup should use nodePort as port", diff --git a/pkg/ingress/model_builder.go b/pkg/ingress/model_builder.go index ec753247de..005f74e629 100644 --- a/pkg/ingress/model_builder.go +++ b/pkg/ingress/model_builder.go @@ -2,11 +2,11 @@ package ingress import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "reflect" "strconv" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -206,10 +206,10 @@ type defaultModelBuildTask struct { defaultBackendProtocolVersion elbv2model.ProtocolVersion defaultHealthCheckPathHTTP string defaultHealthCheckPathGRPC string - defaultHealthCheckTimeoutSeconds int64 - defaultHealthCheckIntervalSeconds int64 - defaultHealthCheckHealthyThresholdCount int64 - defaultHealthCheckUnhealthyThresholdCount int64 + defaultHealthCheckTimeoutSeconds int32 + defaultHealthCheckIntervalSeconds int32 + defaultHealthCheckHealthyThresholdCount int32 + defaultHealthCheckUnhealthyThresholdCount int32 defaultHealthCheckMatcherHTTPCode string defaultHealthCheckMatcherGRPCCode string @@ -235,8 +235,8 @@ func (t *defaultModelBuildTask) run(ctx context.Context) error { return nil } - ingListByPort := make(map[int64][]ClassifiedIngress) - listenPortConfigsByPort := make(map[int64][]listenPortConfigWithIngress) + ingListByPort := make(map[int32][]ClassifiedIngress) + listenPortConfigsByPort := make(map[int32][]listenPortConfigWithIngress) for _, member := range t.ingGroup.Members { ingKey := k8s.NamespacedName(member.Ing) listenPortConfigByPortForIngress, err := t.computeIngressListenPortConfigByPort(ctx, &member) @@ -252,7 +252,7 @@ func (t *defaultModelBuildTask) run(ctx context.Context) error { } } - listenPortConfigByPort := make(map[int64]listenPortConfig) + listenPortConfigByPort := make(map[int32]listenPortConfig) for port, cfgs := range listenPortConfigsByPort { mergedCfg, err := t.mergeListenPortConfigs(ctx, cfgs) if err != nil { @@ -347,9 +347,9 @@ func (t *defaultModelBuildTask) mergeListenPortConfigs(_ context.Context, listen if mergedSSLPolicyProvider == nil { mergedSSLPolicyProvider = &cfg.ingKey mergedSSLPolicy = cfg.listenPortConfig.sslPolicy - } else if awssdk.StringValue(mergedSSLPolicy) != awssdk.StringValue(cfg.listenPortConfig.sslPolicy) { + } else if awssdk.ToString(mergedSSLPolicy) != awssdk.ToString(cfg.listenPortConfig.sslPolicy) { return listenPortConfig{}, errors.Errorf("conflicting sslPolicy, %v: %v | %v: %v", - *mergedSSLPolicyProvider, awssdk.StringValue(mergedSSLPolicy), cfg.ingKey, awssdk.StringValue(cfg.listenPortConfig.sslPolicy)) + *mergedSSLPolicyProvider, awssdk.ToString(mergedSSLPolicy), cfg.ingKey, awssdk.ToString(cfg.listenPortConfig.sslPolicy)) } } @@ -393,11 +393,11 @@ func (t *defaultModelBuildTask) mergeListenPortConfigs(_ context.Context, listen } // buildSSLRedirectConfig computes the SSLRedirect config for the IngressGroup. Returns nil if there is no SSLRedirect configured. -func (t *defaultModelBuildTask) buildSSLRedirectConfig(ctx context.Context, listenPortConfigByPort map[int64]listenPortConfig) (*SSLRedirectConfig, error) { - explicitSSLRedirectPorts := sets.Int64{} +func (t *defaultModelBuildTask) buildSSLRedirectConfig(ctx context.Context, listenPortConfigByPort map[int32]listenPortConfig) (*SSLRedirectConfig, error) { + explicitSSLRedirectPorts := sets.Int32{} for _, member := range t.ingGroup.Members { - var rawSSLRedirectPort int64 - exists, err := t.annotationParser.ParseInt64Annotation(annotations.IngressSuffixSSLRedirect, &rawSSLRedirectPort, member.Ing.Annotations) + var rawSSLRedirectPort int32 + exists, err := t.annotationParser.ParseInt32Annotation(annotations.IngressSuffixSSLRedirect, &rawSSLRedirectPort, member.Ing.Annotations) if err != nil { return nil, errors.Wrapf(err, "ingress: %v", k8s.NamespacedName(member.Ing)) } @@ -421,7 +421,7 @@ func (t *defaultModelBuildTask) buildSSLRedirectConfig(ctx context.Context, list return &SSLRedirectConfig{ SSLPort: rawSSLRedirectPort, - StatusCode: elbv2sdk.RedirectActionStatusCodeEnumHttp301, + StatusCode: string(elbv2types.RedirectActionStatusCodeEnumHttp301), }, nil } diff --git a/pkg/ingress/model_builder_test.go b/pkg/ingress/model_builder_test.go index 8ed6cc13fc..99d9fb066d 100644 --- a/pkg/ingress/model_builder_test.go +++ b/pkg/ingress/model_builder_test.go @@ -3,12 +3,12 @@ package ingress import ( "context" "encoding/json" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" "time" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" jsonpatch "github.com/evanphx/json-patch" "github.com/go-logr/logr" "github.com/golang/mock/gomock" @@ -442,7 +442,7 @@ const baseStackJSON = ` func Test_defaultModelBuilder_Build(t *testing.T) { type resolveViaDiscoveryCall struct { - subnets []*ec2sdk.Subnet + subnets []ec2types.Subnet err error } type env struct { @@ -453,7 +453,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { err error } type describeSecurityGroupsResult struct { - securityGroups []*ec2sdk.SecurityGroup + securityGroups []ec2types.SecurityGroup err error } type fields struct { @@ -576,7 +576,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { } resolveViaDiscoveryCallForInternalLB := resolveViaDiscoveryCall{ - subnets: []*ec2sdk.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-a"), CidrBlock: awssdk.String("192.168.0.0/19"), @@ -588,7 +588,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { }, } resolveViaDiscoveryCallForInternetFacingLB := resolveViaDiscoveryCall{ - subnets: []*ec2sdk.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-c"), CidrBlock: awssdk.String("192.168.64.0/19"), @@ -2152,9 +2152,9 @@ func Test_defaultModelBuilder_Build(t *testing.T) { { matchedLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("lb-1"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + AvailabilityZones: []elbv2types.AvailabilityZone{ { SubnetId: awssdk.String("subnet-e"), }, @@ -2162,7 +2162,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { SubnetId: awssdk.String("subnet-f"), }, }, - Scheme: awssdk.String("internal"), + Scheme: elbv2types.LoadBalancerSchemeEnumInternal, }, Tags: map[string]string{ "elbv2.k8s.aws/cluster": "cluster-name", @@ -2170,9 +2170,9 @@ func Test_defaultModelBuilder_Build(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("lb-2"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + AvailabilityZones: []elbv2types.AvailabilityZone{ { SubnetId: awssdk.String("subnet-e"), }, @@ -2180,7 +2180,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { SubnetId: awssdk.String("subnet-f"), }, }, - Scheme: awssdk.String("internal"), + Scheme: elbv2types.LoadBalancerSchemeEnumInternal, }, Tags: map[string]string{ "keyA": "valueA2", @@ -2188,9 +2188,9 @@ func Test_defaultModelBuilder_Build(t *testing.T) { }, }, { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: awssdk.String("lb-3"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + AvailabilityZones: []elbv2types.AvailabilityZone{ { SubnetId: awssdk.String("subnet-e"), }, @@ -2198,7 +2198,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { SubnetId: awssdk.String("subnet-f"), }, }, - Scheme: awssdk.String("internal"), + Scheme: elbv2types.LoadBalancerSchemeEnumInternal, }, Tags: map[string]string{ "keyA": "valueA3", @@ -2339,7 +2339,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { listLoadBalancersCalls: []listLoadBalancersCall{listLoadBalancerCallForEmptyLB}, describeSecurityGroupsResult: []describeSecurityGroupsResult{ { - securityGroups: []*ec2sdk.SecurityGroup{ + securityGroups: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-manual"), }, @@ -2478,7 +2478,7 @@ func Test_defaultModelBuilder_Build(t *testing.T) { listLoadBalancersCalls: []listLoadBalancersCall{listLoadBalancerCallForEmptyLB}, describeSecurityGroupsResult: []describeSecurityGroupsResult{ { - securityGroups: []*ec2sdk.SecurityGroup{ + securityGroups: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-manual"), }, @@ -3768,7 +3768,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { ingGroup Group } type args struct { - listenPortConfigByPort map[int64]listenPortConfig + listenPortConfigByPort map[int32]listenPortConfig } tests := []struct { name string @@ -3818,7 +3818,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -3874,7 +3874,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -3933,7 +3933,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -3989,7 +3989,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -4073,7 +4073,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -4160,7 +4160,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -4253,7 +4253,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, @@ -4346,7 +4346,7 @@ func Test_defaultModelBuildTask_buildSSLRedirectConfig(t *testing.T) { }, }, args: args{ - listenPortConfigByPort: map[int64]listenPortConfig{ + listenPortConfigByPort: map[int32]listenPortConfig{ 80: { protocol: elbv2model.ProtocolHTTP, }, diff --git a/pkg/ingress/reference_indexer.go b/pkg/ingress/reference_indexer.go index 76c219246c..9cfb4ca73b 100644 --- a/pkg/ingress/reference_indexer.go +++ b/pkg/ingress/reference_indexer.go @@ -3,7 +3,7 @@ package ingress import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" networking "k8s.io/api/networking/v1" "k8s.io/apimachinery/pkg/util/sets" @@ -98,7 +98,7 @@ func (i *defaultReferenceIndexer) BuildIngressClassRefIndexes(_ context.Context, return nil } - ingClassName := awssdk.StringValue(ing.Spec.IngressClassName) + ingClassName := awssdk.ToString(ing.Spec.IngressClassName) return []string{ingClassName} } diff --git a/pkg/ingress/reference_indexer_test.go b/pkg/ingress/reference_indexer_test.go index 1802d6361d..0c463c5ae0 100644 --- a/pkg/ingress/reference_indexer_test.go +++ b/pkg/ingress/reference_indexer_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/stretchr/testify/assert" networking "k8s.io/api/networking/v1" diff --git a/pkg/ingress/rule_optimizer.go b/pkg/ingress/rule_optimizer.go index 395893ea90..019b6b02bc 100644 --- a/pkg/ingress/rule_optimizer.go +++ b/pkg/ingress/rule_optimizer.go @@ -3,7 +3,7 @@ package ingress import ( "context" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/sets" elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" @@ -17,7 +17,7 @@ type Rule struct { // RuleOptimizer will optimize the listener Rules for a single Listener. type RuleOptimizer interface { - Optimize(ctx context.Context, port int64, protocol elbv2model.Protocol, rules []Rule) ([]Rule, error) + Optimize(ctx context.Context, port int32, protocol elbv2model.Protocol, rules []Rule) ([]Rule, error) } // NewDefaultRuleOptimizer constructs new defaultRuleOptimizer. @@ -43,13 +43,13 @@ type defaultRuleOptimizer struct { logger logr.Logger } -func (o *defaultRuleOptimizer) Optimize(_ context.Context, port int64, protocol elbv2model.Protocol, rules []Rule) ([]Rule, error) { +func (o *defaultRuleOptimizer) Optimize(_ context.Context, port int32, protocol elbv2model.Protocol, rules []Rule) ([]Rule, error) { optimizedRules := o.omitInfiniteRedirectRules(port, protocol, rules) optimizedRules = o.omitOvershadowedRulesAfterRedirectRules(optimizedRules) return optimizedRules, nil } -func (o *defaultRuleOptimizer) omitInfiniteRedirectRules(port int64, protocol elbv2model.Protocol, rules []Rule) []Rule { +func (o *defaultRuleOptimizer) omitInfiniteRedirectRules(port int32, protocol elbv2model.Protocol, rules []Rule) []Rule { var optimizedRules []Rule for _, rule := range rules { if isInfiniteRedirectRule(port, protocol, rule) { @@ -84,7 +84,7 @@ func (o *defaultRuleOptimizer) omitOvershadowedRulesAfterRedirectRules(rules []R } // isInfiniteRedirectRule checks whether specified rule will cause a infinite redirect loop. -func isInfiniteRedirectRule(port int64, protocol elbv2model.Protocol, rule Rule) bool { +func isInfiniteRedirectRule(port int32, protocol elbv2model.Protocol, rule Rule) bool { redirectActionCFG := findRedirectActionConfig(rule.Actions) if redirectActionCFG == nil { return false @@ -102,32 +102,32 @@ func isInfiniteRedirectRule(port int64, protocol elbv2model.Protocol, rule Rule) } if redirectActionCFG.Host != nil { - redirectHost := awssdk.StringValue(redirectActionCFG.Host) + redirectHost := awssdk.ToString(redirectActionCFG.Host) if redirectHost != "#{host}" && !ruleHosts.Has(redirectHost) { return false } } if redirectActionCFG.Path != nil { - redirectPath := awssdk.StringValue(redirectActionCFG.Path) + redirectPath := awssdk.ToString(redirectActionCFG.Path) if redirectPath != "/#{path}" && !rulePaths.Has(redirectPath) { return false } } if redirectActionCFG.Port != nil { - redirectPort := awssdk.StringValue(redirectActionCFG.Port) + redirectPort := awssdk.ToString(redirectActionCFG.Port) rulePort := fmt.Sprintf("%v", port) if redirectPort != "#{port}" && redirectPort != rulePort { return false } } if redirectActionCFG.Protocol != nil { - redirectProtocol := awssdk.StringValue(redirectActionCFG.Protocol) + redirectProtocol := awssdk.ToString(redirectActionCFG.Protocol) if redirectProtocol != "#{protocol}" && redirectProtocol != string(protocol) { return false } } if redirectActionCFG.Query != nil { - redirectQuery := awssdk.StringValue(redirectActionCFG.Query) + redirectQuery := awssdk.ToString(redirectActionCFG.Query) if redirectQuery != "#{query}" { return false } diff --git a/pkg/ingress/rule_optimizer_test.go b/pkg/ingress/rule_optimizer_test.go index ef431ef6bb..b76ba11150 100644 --- a/pkg/ingress/rule_optimizer_test.go +++ b/pkg/ingress/rule_optimizer_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/stretchr/testify/assert" elbv2model "sigs.k8s.io/aws-load-balancer-controller/pkg/model/elbv2" @@ -13,7 +13,7 @@ import ( func Test_defaultRuleOptimizer_Optimize(t *testing.T) { type args struct { - port int64 + port int32 protocol elbv2model.Protocol rules []Rule } @@ -250,7 +250,7 @@ func Test_defaultRuleOptimizer_Optimize(t *testing.T) { func Test_isInfiniteRedirectRule(t *testing.T) { type args struct { - port int64 + port int32 protocol elbv2model.Protocol rule Rule } diff --git a/pkg/ingress/ssl_redirect_config.go b/pkg/ingress/ssl_redirect_config.go index 56ae18d051..dd521c088a 100644 --- a/pkg/ingress/ssl_redirect_config.go +++ b/pkg/ingress/ssl_redirect_config.go @@ -3,7 +3,7 @@ package ingress // SSLRedirectConfig contains configuration for SSLRedirect feature. type SSLRedirectConfig struct { // The SSLPort to redirect to for all HTTP port - SSLPort int64 + SSLPort int32 // The HTTP response code. StatusCode string } diff --git a/pkg/model/ec2/security_group_ingress.go b/pkg/model/ec2/security_group_ingress.go index 415c137f19..9edb1c28c1 100644 --- a/pkg/model/ec2/security_group_ingress.go +++ b/pkg/model/ec2/security_group_ingress.go @@ -27,9 +27,9 @@ type PrefixList struct { type IPPermission struct { IPProtocol string `json:"ipProtocol"` // +optional - FromPort *int64 `json:"fromPort,omitempty"` + FromPort *int32 `json:"fromPort,omitempty"` // +optional - ToPort *int64 `json:"toPort,omitempty"` + ToPort *int32 `json:"toPort,omitempty"` // +optional IPRanges []IPRange `json:"ipRanges,omitempty"` // +optional diff --git a/pkg/model/elbv2/listener.go b/pkg/model/elbv2/listener.go index b36013e86c..e7cec3e621 100644 --- a/pkg/model/elbv2/listener.go +++ b/pkg/model/elbv2/listener.go @@ -122,7 +122,7 @@ type AuthenticateCognitoActionConfig struct { // The behavior if the user is not authenticated. // +optional - OnUnauthenticatedRequest *AuthenticateCognitoActionConditionalBehavior `json:"onUnauthenticatedRequest,omitempty"` + OnUnauthenticatedRequest AuthenticateCognitoActionConditionalBehavior `json:"onUnauthenticatedRequest,omitempty"` // The set of user claims to be requested from the IdP. // +optional @@ -162,7 +162,7 @@ type AuthenticateOIDCActionConfig struct { // The behavior if the user is not authenticated. // +optional - OnUnauthenticatedRequest *AuthenticateOIDCActionConditionalBehavior `json:"onUnauthenticatedRequest,omitempty"` + OnUnauthenticatedRequest AuthenticateOIDCActionConditionalBehavior `json:"onUnauthenticatedRequest,omitempty"` // The set of user claims to be requested from the IdP. // +optional @@ -252,7 +252,7 @@ type TargetGroupTuple struct { // The weight. // +optional - Weight *int64 `json:"weight,omitempty"` + Weight *int32 `json:"weight,omitempty"` } // Information about the target group stickiness for a rule. @@ -263,7 +263,7 @@ type TargetGroupStickinessConfig struct { // The time period, in seconds, during which requests from a client should be routed to the same target group. // +optional - DurationSeconds *int64 `json:"durationSeconds,omitempty"` + DurationSeconds *int32 `json:"durationSeconds,omitempty"` } // Information about a forward action. @@ -328,7 +328,7 @@ type ListenerSpec struct { LoadBalancerARN core.StringToken `json:"loadBalancerARN"` // The port on which the load balancer is listening. - Port int64 `json:"port"` + Port int32 `json:"port"` // The protocol for connections from clients to the load balancer. Protocol Protocol `json:"protocol"` diff --git a/pkg/model/elbv2/listener_rule.go b/pkg/model/elbv2/listener_rule.go index 3e3ed2632a..723b0b3e1c 100644 --- a/pkg/model/elbv2/listener_rule.go +++ b/pkg/model/elbv2/listener_rule.go @@ -130,7 +130,7 @@ type ListenerRuleSpec struct { // The Amazon Resource Name (ARN) of the listener. ListenerARN core.StringToken `json:"listenerARN"` // The rule priority. - Priority int64 `json:"priority"` + Priority int32 `json:"priority"` // The actions. Actions []Action `json:"actions"` // The conditions. diff --git a/pkg/model/elbv2/listener_test.go b/pkg/model/elbv2/listener_test.go index 0c2283118c..8f1addc0f1 100644 --- a/pkg/model/elbv2/listener_test.go +++ b/pkg/model/elbv2/listener_test.go @@ -2,7 +2,7 @@ package elbv2 import ( "encoding/json" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/stretchr/testify/assert" "testing" ) @@ -31,7 +31,7 @@ func TestAuthenticateOIDCActionConfig_MarshalJSON(t *testing.T) { name: "clientID and clientSecret should be redacted", cfg: &AuthenticateOIDCActionConfig{ AuthenticationRequestExtraParams: map[string]string{"key": "value"}, - OnUnauthenticatedRequest: &deny, + OnUnauthenticatedRequest: deny, Scope: awssdk.String("oidc"), SessionCookieName: awssdk.String("my-cookie"), Issuer: "my-issuer", diff --git a/pkg/model/elbv2/load_balancer.go b/pkg/model/elbv2/load_balancer.go index 46cd6c375a..139a2b79b1 100644 --- a/pkg/model/elbv2/load_balancer.go +++ b/pkg/model/elbv2/load_balancer.go @@ -138,11 +138,11 @@ type LoadBalancerSpec struct { // The nodes of an Internet-facing load balancer have public IP addresses. // The nodes of an internal load balancer have only private IP addresses. // +optional - Scheme *LoadBalancerScheme `json:"scheme,omitempty"` + Scheme LoadBalancerScheme `json:"scheme,omitempty"` // The type of IP addresses used by the subnets for your load balancer. // +optional - IPAddressType *IPAddressType `json:"ipAddressType,omitempty"` + IPAddressType IPAddressType `json:"ipAddressType,omitempty"` // The IDs of the public subnets. You can specify only one subnet per Availability Zone. // +optional diff --git a/pkg/model/elbv2/target_group.go b/pkg/model/elbv2/target_group.go index ddeb02d877..ffd6a3e12a 100644 --- a/pkg/model/elbv2/target_group.go +++ b/pkg/model/elbv2/target_group.go @@ -81,7 +81,7 @@ type TargetGroupHealthCheckConfig struct { // The protocol the load balancer uses when performing health checks on targets. // +optional - Protocol *Protocol `json:"protocol,omitempty"` + Protocol Protocol `json:"protocol,omitempty"` // [HTTP/HTTPS health checks] The ping path that is the destination on the targets for health checks. // +optional @@ -93,19 +93,19 @@ type TargetGroupHealthCheckConfig struct { // The approximate amount of time, in seconds, between health checks of an individual target. // +optional - IntervalSeconds *int64 `json:"intervalSeconds,omitempty"` + IntervalSeconds *int32 `json:"intervalSeconds,omitempty"` // The amount of time, in seconds, during which no response from a target means a failed health check. // +optional - TimeoutSeconds *int64 `json:"timeoutSeconds,omitempty"` + TimeoutSeconds *int32 `json:"timeoutSeconds,omitempty"` // The number of consecutive health checks successes required before considering an unhealthy target healthy. // +optional - HealthyThresholdCount *int64 `json:"healthyThresholdCount,omitempty"` + HealthyThresholdCount *int32 `json:"healthyThresholdCount,omitempty"` // The number of consecutive health check failures required before considering a target unhealthy. // +optional - UnhealthyThresholdCount *int64 `json:"unhealthyThresholdCount,omitempty"` + UnhealthyThresholdCount *int32 `json:"unhealthyThresholdCount,omitempty"` } // Specifies a target group attribute. @@ -126,7 +126,7 @@ type TargetGroupSpec struct { TargetType TargetType `json:"targetType"` // The port on which the targets receive traffic. - Port int64 `json:"port"` + Port *int32 `json:"port"` // The protocol to use for routing traffic to the targets. Protocol Protocol `json:"protocol"` @@ -137,7 +137,7 @@ type TargetGroupSpec struct { // Target group IP address type IPv4 or IPv6 // +optional - IPAddressType *TargetGroupIPAddressType `json:"ipAddressType,omitempty"` + IPAddressType TargetGroupIPAddressType `json:"ipAddressType,omitempty"` // Configuration for TargetGroup's HealthCheck. // +optional diff --git a/pkg/model/elbv2/target_group_binding.go b/pkg/model/elbv2/target_group_binding.go index 30d8d159b7..173eb81dec 100644 --- a/pkg/model/elbv2/target_group_binding.go +++ b/pkg/model/elbv2/target_group_binding.go @@ -102,7 +102,7 @@ type TargetGroupBindingSpec struct { // ipAddressType specifies whether the target group is of type IPv4 or IPv6. If unspecified, it will be automatically inferred. // +optional - IPAddressType *elbv2api.TargetGroupIPAddressType `json:"ipAddressType,omitempty"` + IPAddressType elbv2api.TargetGroupIPAddressType `json:"ipAddressType,omitempty"` // VpcID is the VPC of the TargetGroup. If unspecified, it will be automatically inferred. // +optional diff --git a/pkg/networking/az_info_provider.go b/pkg/networking/az_info_provider.go index 215c7c7d4e..e3bfa42dd6 100644 --- a/pkg/networking/az_info_provider.go +++ b/pkg/networking/az_info_provider.go @@ -2,8 +2,9 @@ package networking import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -12,14 +13,14 @@ import ( // AZInfoProvider is responsible for provide AZ info. type AZInfoProvider interface { - FetchAZInfos(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2sdk.AvailabilityZone, error) + FetchAZInfos(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2types.AvailabilityZone, error) } // NewDefaultAZInfoProvider constructs new defaultAZInfoProvider. func NewDefaultAZInfoProvider(ec2Client services.EC2, logger logr.Logger) *defaultAZInfoProvider { return &defaultAZInfoProvider{ ec2Client: ec2Client, - azInfoCache: make(map[string]ec2sdk.AvailabilityZone), + azInfoCache: make(map[string]ec2types.AvailabilityZone), azInfoCacheMutex: sync.RWMutex{}, logger: logger, } @@ -31,13 +32,13 @@ var _ AZInfoProvider = &defaultAZInfoProvider{} // AZ info for each zone is cached indefinitely. type defaultAZInfoProvider struct { ec2Client services.EC2 - azInfoCache map[string]ec2sdk.AvailabilityZone + azInfoCache map[string]ec2types.AvailabilityZone azInfoCacheMutex sync.RWMutex logger logr.Logger } -func (p *defaultAZInfoProvider) FetchAZInfos(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2sdk.AvailabilityZone, error) { +func (p *defaultAZInfoProvider) FetchAZInfos(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2types.AvailabilityZone, error) { azInfoByAZID := p.fetchAZInfosFromCache(availabilityZoneIDs) azIDsWithoutAZInfo := computeAZIDsWithoutAZInfo(availabilityZoneIDs, azInfoByAZID) if len(azIDsWithoutAZInfo) == 0 { @@ -62,11 +63,11 @@ func (p *defaultAZInfoProvider) FetchAZInfos(ctx context.Context, availabilityZo return azInfoByAZID, nil } -func (p *defaultAZInfoProvider) fetchAZInfosFromCache(availabilityZoneIDs []string) map[string]ec2sdk.AvailabilityZone { +func (p *defaultAZInfoProvider) fetchAZInfosFromCache(availabilityZoneIDs []string) map[string]ec2types.AvailabilityZone { p.azInfoCacheMutex.RLock() defer p.azInfoCacheMutex.RUnlock() - azInfoByAZID := make(map[string]ec2sdk.AvailabilityZone) + azInfoByAZID := make(map[string]ec2types.AvailabilityZone) for _, azID := range availabilityZoneIDs { if azInfo, exists := p.azInfoCache[azID]; exists { azInfoByAZID[azID] = azInfo @@ -75,7 +76,7 @@ func (p *defaultAZInfoProvider) fetchAZInfosFromCache(availabilityZoneIDs []stri return azInfoByAZID } -func (p *defaultAZInfoProvider) saveAZInfosToCache(azInfoByAZID map[string]ec2sdk.AvailabilityZone) { +func (p *defaultAZInfoProvider) saveAZInfosToCache(azInfoByAZID map[string]ec2types.AvailabilityZone) { p.azInfoCacheMutex.Lock() defer p.azInfoCacheMutex.Unlock() @@ -86,23 +87,23 @@ func (p *defaultAZInfoProvider) saveAZInfosToCache(azInfoByAZID map[string]ec2sd // fetchAZInfosFromAWS will fetch AZ info from AWS API. // the availabilityZoneIDs shouldn't be empty. -func (p *defaultAZInfoProvider) fetchAZInfosFromAWS(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2sdk.AvailabilityZone, error) { +func (p *defaultAZInfoProvider) fetchAZInfosFromAWS(ctx context.Context, availabilityZoneIDs []string) (map[string]ec2types.AvailabilityZone, error) { req := &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice(availabilityZoneIDs), + ZoneIds: availabilityZoneIDs, } resp, err := p.ec2Client.DescribeAvailabilityZonesWithContext(ctx, req) if err != nil { return nil, err } - azInfoByAZID := make(map[string]ec2sdk.AvailabilityZone) + azInfoByAZID := make(map[string]ec2types.AvailabilityZone) for _, azInfo := range resp.AvailabilityZones { - azInfoByAZID[awssdk.StringValue(azInfo.ZoneId)] = *azInfo + azInfoByAZID[awssdk.ToString(azInfo.ZoneId)] = azInfo } return azInfoByAZID, nil } // computeAZIDsWithoutAZInfo computes az IDs that don't have az Info. -func computeAZIDsWithoutAZInfo(availabilityZoneIDs []string, azInfoByAZID map[string]ec2sdk.AvailabilityZone) []string { +func computeAZIDsWithoutAZInfo(availabilityZoneIDs []string, azInfoByAZID map[string]ec2types.AvailabilityZone) []string { azIDsWithoutAZInfo := make([]string, 0, len(availabilityZoneIDs)-len(azInfoByAZID)) for _, azID := range availabilityZoneIDs { if _, ok := azInfoByAZID[azID]; !ok { diff --git a/pkg/networking/az_info_provider_mocks.go b/pkg/networking/az_info_provider_mocks.go index e58a4c1b52..7f7742ed1e 100644 --- a/pkg/networking/az_info_provider_mocks.go +++ b/pkg/networking/az_info_provider_mocks.go @@ -8,7 +8,7 @@ import ( context "context" reflect "reflect" - ec2 "github.com/aws/aws-sdk-go/service/ec2" + types "github.com/aws/aws-sdk-go-v2/service/ec2/types" gomock "github.com/golang/mock/gomock" ) @@ -36,10 +36,10 @@ func (m *MockAZInfoProvider) EXPECT() *MockAZInfoProviderMockRecorder { } // FetchAZInfos mocks base method. -func (m *MockAZInfoProvider) FetchAZInfos(arg0 context.Context, arg1 []string) (map[string]ec2.AvailabilityZone, error) { +func (m *MockAZInfoProvider) FetchAZInfos(arg0 context.Context, arg1 []string) (map[string]types.AvailabilityZone, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FetchAZInfos", arg0, arg1) - ret0, _ := ret[0].(map[string]ec2.AvailabilityZone) + ret0, _ := ret[0].(map[string]types.AvailabilityZone) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/pkg/networking/az_info_provider_test.go b/pkg/networking/az_info_provider_test.go index 4638cf2728..1e4fa9897c 100644 --- a/pkg/networking/az_info_provider_test.go +++ b/pkg/networking/az_info_provider_test.go @@ -2,10 +2,11 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -29,7 +30,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { } type fetchAZInfoCall struct { args args - want map[string]ec2sdk.AvailabilityZone + want map[string]ec2types.AvailabilityZone wantErr error } tests := []struct { @@ -43,10 +44,10 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1"}), + ZoneIds: []string{"usw2-az1"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -56,10 +57,10 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { }, { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az2"}), + ZoneIds: []string{"usw2-az2"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -74,7 +75,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -85,7 +86,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az2"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -100,10 +101,10 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1", "usw2-az2"}), + ZoneIds: []string{"usw2-az1", "usw2-az2"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -122,7 +123,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1", "usw2-az2"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -141,10 +142,10 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1"}), + ZoneIds: []string{"usw2-az1"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -154,10 +155,10 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { }, { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az2"}), + ZoneIds: []string{"usw2-az2"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -172,7 +173,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -183,7 +184,7 @@ func Test_defaultAZInfoProvider_FetchAZInfos(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1", "usw2-az2"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -238,7 +239,7 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { name string fields fields args args - want map[string]ec2sdk.AvailabilityZone + want map[string]ec2types.AvailabilityZone wantErr error }{ { @@ -247,10 +248,10 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1"}), + ZoneIds: []string{"usw2-az1"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -263,7 +264,7 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -276,10 +277,10 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1", "usw2-az2"}), + ZoneIds: []string{"usw2-az1", "usw2-az2"}, }, output: &ec2sdk.DescribeAvailabilityZonesOutput{ - AvailabilityZones: []*ec2sdk.AvailabilityZone{ + AvailabilityZones: []ec2types.AvailabilityZone{ { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -296,7 +297,7 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { args: args{ availabilityZoneIDs: []string{"usw2-az1", "usw2-az2"}, }, - want: map[string]ec2sdk.AvailabilityZone{ + want: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -313,7 +314,7 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { describeAvailabilityZonesCalls: []describeAvailabilityZonesCall{ { input: &ec2sdk.DescribeAvailabilityZonesInput{ - ZoneIds: awssdk.StringSlice([]string{"usw2-az1", "wrong-az-id"}), + ZoneIds: []string{"usw2-az1", "wrong-az-id"}, }, output: nil, err: errors.New("Invalid availability zone-id: wrong-az-id"), @@ -353,7 +354,7 @@ func Test_defaultAZInfoProvider_fetchAZInfosFromAWS(t *testing.T) { func Test_computeAZIDsWithoutAZInfo(t *testing.T) { type args struct { availabilityZoneIDs []string - azInfoByAZID map[string]ec2sdk.AvailabilityZone + azInfoByAZID map[string]ec2types.AvailabilityZone } tests := []struct { name string @@ -364,7 +365,7 @@ func Test_computeAZIDsWithoutAZInfo(t *testing.T) { name: "all AZs have AZInfo", args: args{ availabilityZoneIDs: []string{"usw2-az1", "usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": {}, "usw2-az2": {}, }, @@ -375,7 +376,7 @@ func Test_computeAZIDsWithoutAZInfo(t *testing.T) { name: "some AZ don't have AZInfo - non-empty azInfoByAZID", args: args{ availabilityZoneIDs: []string{"usw2-az1", "usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": {}, }, }, diff --git a/pkg/networking/backend_sg_provider.go b/pkg/networking/backend_sg_provider.go index 000d266095..8b3900e523 100644 --- a/pkg/networking/backend_sg_provider.go +++ b/pkg/networking/backend_sg_provider.go @@ -5,15 +5,16 @@ import ( "crypto/sha256" "encoding/hex" "fmt" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go" "regexp" "sort" "strings" "sync" "time" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -248,25 +249,25 @@ func (p *defaultBackendSGProvider) allocateBackendSG(ctx context.Context, resour return err } p.logger.Info("created SecurityGroup", "name", sgName, "id", resp.GroupId) - p.autoGeneratedSG = awssdk.StringValue(resp.GroupId) + p.autoGeneratedSG = awssdk.ToString(resp.GroupId) return nil } -func (p *defaultBackendSGProvider) buildBackendSGTags(_ context.Context) []*ec2sdk.TagSpecification { - var defaultTags []*ec2sdk.Tag +func (p *defaultBackendSGProvider) buildBackendSGTags(_ context.Context) []ec2types.TagSpecification { + var defaultTags []ec2types.Tag for key, val := range p.defaultTags { - defaultTags = append(defaultTags, &ec2sdk.Tag{ + defaultTags = append(defaultTags, ec2types.Tag{ Key: awssdk.String(key), Value: awssdk.String(val), }) } sort.Slice(defaultTags, func(i, j int) bool { - return awssdk.StringValue(defaultTags[i].Key) < awssdk.StringValue(defaultTags[j].Key) + return awssdk.ToString(defaultTags[i].Key) < awssdk.ToString(defaultTags[j].Key) }) - return []*ec2sdk.TagSpecification{ + return []ec2types.TagSpecification{ { - ResourceType: awssdk.String(resourceTypeSecurityGroup), - Tags: append(defaultTags, []*ec2sdk.Tag{ + ResourceType: resourceTypeSecurityGroup, + Tags: append(defaultTags, []ec2types.Tag{ { Key: awssdk.String(tagKeyK8sCluster), Value: awssdk.String(p.clusterName), @@ -282,18 +283,18 @@ func (p *defaultBackendSGProvider) buildBackendSGTags(_ context.Context) []*ec2s func (p *defaultBackendSGProvider) getBackendSGFromEC2(ctx context.Context, sgName string, vpcID string) (string, error) { req := &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{vpcID}), + Values: []string{vpcID}, }, { Name: awssdk.String(fmt.Sprintf("tag:%v", tagKeyK8sCluster)), - Values: awssdk.StringSlice([]string{p.clusterName}), + Values: []string{p.clusterName}, }, { Name: awssdk.String(fmt.Sprintf("tag:%v", tagKeyResource)), - Values: awssdk.StringSlice([]string{tagValueBackend}), + Values: []string{tagValueBackend}, }, }, } @@ -303,7 +304,7 @@ func (p *defaultBackendSGProvider) getBackendSGFromEC2(ctx context.Context, sgNa return "", err } if len(sgs) > 0 { - return awssdk.StringValue(sgs[0].GroupId), nil + return awssdk.ToString(sgs[0].GroupId), nil } return "", nil } @@ -345,17 +346,17 @@ func (p *defaultBackendSGProvider) getBackendSGName() string { } func isSecurityGroupDependencyViolationError(err error) bool { - var awsErr awserr.Error - if errors.As(err, &awsErr) { - return awsErr.Code() == "DependencyViolation" + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + return apiErr.ErrorCode() == "DependencyViolation" } return false } func isEC2SecurityGroupNotFoundError(err error) bool { - var awsErr awserr.Error - if errors.As(err, &awsErr) { - return awsErr.Code() == "InvalidGroup.NotFound" + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + return apiErr.ErrorCode() == "InvalidGroup.NotFound" } return false } diff --git a/pkg/networking/backend_sg_provider_test.go b/pkg/networking/backend_sg_provider_test.go index 21a0e77248..4850d7d30d 100644 --- a/pkg/networking/backend_sg_provider_test.go +++ b/pkg/networking/backend_sg_provider_test.go @@ -2,6 +2,8 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go" "k8s.io/apimachinery/pkg/types" "reflect" "sigs.k8s.io/aws-load-balancer-controller/pkg/k8s" @@ -14,9 +16,8 @@ import ( mock_client "sigs.k8s.io/aws-load-balancer-controller/mocks/controller-runtime/client" "sigs.k8s.io/controller-runtime/pkg/client" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/golang/mock/gomock" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -32,7 +33,7 @@ const ( func Test_defaultBackendSGProvider_Get(t *testing.T) { type describeSecurityGroupsAsListCall struct { req *ec2sdk.DescribeSecurityGroupsInput - resp []*ec2sdk.SecurityGroup + resp []ec2types.SecurityGroup err error } type createSecurityGroupWithContexCall struct { @@ -48,18 +49,18 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { describeSGCalls []describeSecurityGroupsAsListCall createSGCalls []createSecurityGroupWithContexCall } - defaultEC2Filters := []*ec2sdk.Filter{ + defaultEC2Filters := []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, { Name: awssdk.String("tag:elbv2.k8s.aws/cluster"), - Values: awssdk.StringSlice([]string{"testCluster"}), + Values: []string{"testCluster"}, }, { Name: awssdk.String("tag:elbv2.k8s.aws/resource"), - Values: awssdk.StringSlice([]string{"backend-sg"}), + Values: []string{"backend-sg"}, }, } ing := &networking.Ingress{ @@ -102,7 +103,7 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.DescribeSecurityGroupsInput{ Filters: defaultEC2Filters, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-autogen"), }, @@ -121,7 +122,7 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.DescribeSecurityGroupsInput{ Filters: defaultEC2Filters, }, - err: awserr.New("InvalidGroup.NotFound", "", nil), + err: &smithy.GenericAPIError{Code: "InvalidGroup.NotFound", Message: ""}, }, }, createSGCalls: []createSecurityGroupWithContexCall{ @@ -129,10 +130,10 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.CreateSecurityGroupInput{ Description: awssdk.String(sgDescription), GroupName: awssdk.String("k8s-traffic-testCluster-411a1bcdb1"), - TagSpecifications: []*ec2sdk.TagSpecification{ + TagSpecifications: []ec2types.TagSpecification{ { - ResourceType: awssdk.String("security-group"), - Tags: []*ec2sdk.Tag{ + ResourceType: ec2types.ResourceType("security-group"), + Tags: []ec2types.Tag{ { Key: awssdk.String("elbv2.k8s.aws/cluster"), Value: awssdk.String(defaultClusterName), @@ -163,7 +164,7 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.DescribeSecurityGroupsInput{ Filters: defaultEC2Filters, }, - err: awserr.New("InvalidGroup.NotFound", "", nil), + err: &smithy.GenericAPIError{Code: "InvalidGroup.NotFound", Message: ""}, }, }, createSGCalls: []createSecurityGroupWithContexCall{ @@ -171,10 +172,10 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.CreateSecurityGroupInput{ Description: awssdk.String(sgDescription), GroupName: awssdk.String("k8s-traffic-testCluster-411a1bcdb1"), - TagSpecifications: []*ec2sdk.TagSpecification{ + TagSpecifications: []ec2types.TagSpecification{ { - ResourceType: awssdk.String("security-group"), - Tags: []*ec2sdk.Tag{ + ResourceType: ec2types.ResourceType("security-group"), + Tags: []ec2types.Tag{ { Key: awssdk.String("KubernetesCluster"), Value: awssdk.String(defaultClusterName), @@ -222,12 +223,12 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.DescribeSecurityGroupsInput{ Filters: defaultEC2Filters, }, - err: awserr.New("Some.Other.Error", "describe security group as list error", nil), + err: &smithy.GenericAPIError{Code: "Some.Other.Error", Message: "describe security group as list error"}, }, }, ingResources: []*networking.Ingress{ing}, }, - wantErr: errors.New("Some.Other.Error: describe security group as list error"), + wantErr: errors.New("api error Some.Other.Error: describe security group as list error"), }, { name: "create SG call returns error", @@ -237,7 +238,7 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.DescribeSecurityGroupsInput{ Filters: defaultEC2Filters, }, - err: awserr.New("InvalidGroup.NotFound", "", nil), + err: &smithy.GenericAPIError{Code: "InvalidGroup.NotFound", Message: ""}, }, }, createSGCalls: []createSecurityGroupWithContexCall{ @@ -245,10 +246,10 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { req: &ec2sdk.CreateSecurityGroupInput{ Description: awssdk.String(sgDescription), GroupName: awssdk.String("k8s-traffic-testCluster-411a1bcdb1"), - TagSpecifications: []*ec2sdk.TagSpecification{ + TagSpecifications: []ec2types.TagSpecification{ { - ResourceType: awssdk.String("security-group"), - Tags: []*ec2sdk.Tag{ + ResourceType: ec2types.ResourceType("security-group"), + Tags: []ec2types.Tag{ { Key: awssdk.String("elbv2.k8s.aws/cluster"), Value: awssdk.String(defaultClusterName), @@ -262,12 +263,12 @@ func Test_defaultBackendSGProvider_Get(t *testing.T) { }, VpcId: awssdk.String(defaultVPCID), }, - err: awserr.New("Create.Error", "unable to create security group", nil), + err: &smithy.GenericAPIError{Code: "Create.Error", Message: "unable to create security group"}, }, }, ingResources: []*networking.Ingress{ing1}, }, - wantErr: errors.New("Create.Error: unable to create security group"), + wantErr: errors.New("api error Create.Error: unable to create security group"), }, } for _, tt := range tests { @@ -659,7 +660,7 @@ func Test_defaultBackendSGProvider_Release(t *testing.T) { req: &ec2sdk.DeleteSecurityGroupInput{ GroupId: awssdk.String("sg-autogen"), }, - err: awserr.New("DependencyViolation", "", nil), + err: &smithy.GenericAPIError{Code: "DependencyViolation", Message: ""}, }, { req: &ec2sdk.DeleteSecurityGroupInput{ @@ -686,12 +687,12 @@ func Test_defaultBackendSGProvider_Release(t *testing.T) { req: &ec2sdk.DeleteSecurityGroupInput{ GroupId: awssdk.String("sg-autogen"), }, - err: awserr.New("Something.Else", "unable to delete SG", nil), + err: &smithy.GenericAPIError{Code: "Something.Else", Message: "unable to delete SG"}, }, }, inactiveIngresses: []*networking.Ingress{ing}, }, - wantErr: errors.New("failed to delete securityGroup: Something.Else: unable to delete SG"), + wantErr: errors.New("failed to delete securityGroup: api error Something.Else: unable to delete SG"), }, { name: "k8s ingress list returns error", diff --git a/pkg/networking/eni_info.go b/pkg/networking/eni_info.go index 685da6f428..79538ead04 100644 --- a/pkg/networking/eni_info.go +++ b/pkg/networking/eni_info.go @@ -1,8 +1,8 @@ package networking import ( - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" ) // ENIInfo wraps necessary information about a ENI. @@ -14,24 +14,24 @@ type ENIInfo struct { SecurityGroups []string } -func buildENIInfoViaENI(eni *ec2.NetworkInterface) ENIInfo { +func buildENIInfoViaENI(eni ec2types.NetworkInterface) ENIInfo { sgIDs := make([]string, 0, len(eni.Groups)) for _, group := range eni.Groups { - sgIDs = append(sgIDs, awssdk.StringValue(group.GroupId)) + sgIDs = append(sgIDs, awssdk.ToString(group.GroupId)) } return ENIInfo{ - NetworkInterfaceID: awssdk.StringValue(eni.NetworkInterfaceId), + NetworkInterfaceID: awssdk.ToString(eni.NetworkInterfaceId), SecurityGroups: sgIDs, } } -func buildENIInfoViaInstanceENI(eni *ec2.InstanceNetworkInterface) ENIInfo { +func buildENIInfoViaInstanceENI(eni ec2types.InstanceNetworkInterface) ENIInfo { sgIDs := make([]string, 0, len(eni.Groups)) for _, group := range eni.Groups { - sgIDs = append(sgIDs, awssdk.StringValue(group.GroupId)) + sgIDs = append(sgIDs, awssdk.ToString(group.GroupId)) } return ENIInfo{ - NetworkInterfaceID: awssdk.StringValue(eni.NetworkInterfaceId), + NetworkInterfaceID: awssdk.ToString(eni.NetworkInterfaceId), SecurityGroups: sgIDs, } } diff --git a/pkg/networking/node_eni_info_resolver.go b/pkg/networking/node_eni_info_resolver.go index c64ef4e3e7..60e23bf811 100644 --- a/pkg/networking/node_eni_info_resolver.go +++ b/pkg/networking/node_eni_info_resolver.go @@ -2,8 +2,8 @@ package networking import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -128,13 +128,13 @@ func (r *defaultNodeENIInfoResolver) resolveViaInstanceID(ctx context.Context, n } // findInstancePrimaryENI returns the primary ENI among list of eni on an EC2 instance -func findInstancePrimaryENI(enis []*ec2sdk.InstanceNetworkInterface) (*ec2sdk.InstanceNetworkInterface, error) { +func findInstancePrimaryENI(enis []ec2types.InstanceNetworkInterface) (ec2types.InstanceNetworkInterface, error) { for _, eni := range enis { - if awssdk.Int64Value(eni.Attachment.DeviceIndex) == 0 { + if awssdk.ToInt32(eni.Attachment.DeviceIndex) == 0 { return eni, nil } } - return nil, errors.Errorf("[this should never happen] no primary ENI found") + return ec2types.InstanceNetworkInterface{}, errors.Errorf("[this should never happen] no primary ENI found") } // computeNodeENIInfoCacheKey computes the cacheKey for node's ENIInfo cache. diff --git a/pkg/networking/node_eni_info_resolver_test.go b/pkg/networking/node_eni_info_resolver_test.go index 7890f52acf..b7d8701fcf 100644 --- a/pkg/networking/node_eni_info_resolver_test.go +++ b/pkg/networking/node_eni_info_resolver_test.go @@ -4,8 +4,8 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -53,15 +53,15 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { ProviderID: "aws:///us-west-2a/i-0fa2d0064e848c69d", }, } - instanceA := &ec2sdk.Instance{ + instanceA := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69a"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -69,15 +69,15 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { }, }, } - instanceB := &ec2sdk.Instance{ + instanceB := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69b"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -85,15 +85,15 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { }, }, } - instanceC := &ec2sdk.Instance{ + instanceC := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69c"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-c-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-c-1"), }, @@ -101,15 +101,15 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { }, }, } - instanceD := &ec2sdk.Instance{ + instanceD := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69d"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-d-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-d-1"), }, @@ -119,7 +119,7 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type fields struct { @@ -144,14 +144,14 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, }, }, { nodes: []*corev1.Node{nodeC, nodeD}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-c"}: instanceC, types.NamespacedName{Name: "node-d"}: instanceD, }, @@ -197,14 +197,14 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, }, }, { nodes: []*corev1.Node{nodeC}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-c"}: instanceC, }, }, @@ -249,7 +249,7 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, }, @@ -291,7 +291,7 @@ func Test_defaultNodeENIInfoResolver_Resolve(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, }, @@ -371,7 +371,7 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type fields struct { @@ -393,16 +393,16 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: { InstanceId: awssdk.String("i-0fa2d0064e848c69a"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -412,13 +412,13 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { }, types.NamespacedName{Name: "node-b"}: { InstanceId: awssdk.String("i-0fa2d0064e848c69b"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -450,16 +450,16 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-b"}: { InstanceId: awssdk.String("i-0fa2d0064e848c69b"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -502,7 +502,7 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: { InstanceId: awssdk.String("i-0fa2d0064e848c69a"), }, @@ -542,72 +542,72 @@ func Test_defaultNodeENIInfoResolver_resolveViaInstanceID(t *testing.T) { func Test_findInstancePrimaryENI(t *testing.T) { type args struct { - enis []*ec2sdk.InstanceNetworkInterface + enis []ec2types.InstanceNetworkInterface } tests := []struct { name string args args - want *ec2sdk.InstanceNetworkInterface + want ec2types.InstanceNetworkInterface wantErr error }{ { name: "one eni", args: args{ - enis: []*ec2sdk.InstanceNetworkInterface{ + enis: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, }, }, }, - want: &ec2sdk.InstanceNetworkInterface{ + want: ec2types.InstanceNetworkInterface{ NetworkInterfaceId: awssdk.String("eni-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, }, }, { name: "two eni", args: args{ - enis: []*ec2sdk.InstanceNetworkInterface{ + enis: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(1), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(1), }, }, { NetworkInterfaceId: awssdk.String("eni-2"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, }, }, }, - want: &ec2sdk.InstanceNetworkInterface{ + want: ec2types.InstanceNetworkInterface{ NetworkInterfaceId: awssdk.String("eni-2"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, }, }, { name: "no primary ENI", args: args{ - enis: []*ec2sdk.InstanceNetworkInterface{ + enis: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-1"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(1), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(1), }, }, { NetworkInterfaceId: awssdk.String("eni-2"), - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(2), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(2), }, }, }, diff --git a/pkg/networking/node_info_provider.go b/pkg/networking/node_info_provider.go index 05af9625f9..80b5bba64d 100644 --- a/pkg/networking/node_info_provider.go +++ b/pkg/networking/node_info_provider.go @@ -2,8 +2,9 @@ package networking import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/types" @@ -17,7 +18,7 @@ import ( // e.g. when resolve pod's ENI, the cachePolicy can be node contains pod's IP and node's cache is fresher than pod's creationTime. type NodeInfoProvider interface { // FetchNodeInstances provides EC2 instance information per k8s node. - FetchNodeInstances(ctx context.Context, nodes []*corev1.Node) (map[types.NamespacedName]*ec2sdk.Instance, error) + FetchNodeInstances(ctx context.Context, nodes []*corev1.Node) (map[types.NamespacedName]*ec2types.Instance, error) } // NewDefaultNodeInfoProvider constructs new defaultNodeInfoProvider. @@ -39,7 +40,7 @@ type defaultNodeInfoProvider struct { logger logr.Logger } -func (p *defaultNodeInfoProvider) FetchNodeInstances(ctx context.Context, nodes []*corev1.Node) (map[types.NamespacedName]*ec2sdk.Instance, error) { +func (p *defaultNodeInfoProvider) FetchNodeInstances(ctx context.Context, nodes []*corev1.Node) (map[types.NamespacedName]*ec2types.Instance, error) { if len(nodes) == 0 { return nil, nil } @@ -54,18 +55,18 @@ func (p *defaultNodeInfoProvider) FetchNodeInstances(ctx context.Context, nodes } instanceIDs := sets.StringKeySet(nodeKeysByInstanceID).List() req := &ec2sdk.DescribeInstancesInput{ - InstanceIds: awssdk.StringSlice(instanceIDs), + InstanceIds: instanceIDs, } instances, err := p.ec2Client.DescribeInstancesAsList(ctx, req) if err != nil { return nil, err } - nodeInstanceByNodeKey := make(map[types.NamespacedName]*ec2sdk.Instance, len(nodes)) + nodeInstanceByNodeKey := make(map[types.NamespacedName]*ec2types.Instance, len(nodes)) for _, instance := range instances { - instanceID := awssdk.StringValue(instance.InstanceId) + instanceID := awssdk.ToString(instance.InstanceId) for _, nodeKey := range nodeKeysByInstanceID[instanceID] { - nodeInstanceByNodeKey[nodeKey] = instance + nodeInstanceByNodeKey[nodeKey] = &instance } } return nodeInstanceByNodeKey, nil diff --git a/pkg/networking/node_info_provider_mocks.go b/pkg/networking/node_info_provider_mocks.go index 3ffa42d14d..4a9b53fcd0 100644 --- a/pkg/networking/node_info_provider_mocks.go +++ b/pkg/networking/node_info_provider_mocks.go @@ -8,10 +8,10 @@ import ( context "context" reflect "reflect" - ec2 "github.com/aws/aws-sdk-go/service/ec2" + types "github.com/aws/aws-sdk-go-v2/service/ec2/types" gomock "github.com/golang/mock/gomock" v1 "k8s.io/api/core/v1" - types "k8s.io/apimachinery/pkg/types" + types0 "k8s.io/apimachinery/pkg/types" ) // MockNodeInfoProvider is a mock of NodeInfoProvider interface. @@ -38,10 +38,10 @@ func (m *MockNodeInfoProvider) EXPECT() *MockNodeInfoProviderMockRecorder { } // FetchNodeInstances mocks base method. -func (m *MockNodeInfoProvider) FetchNodeInstances(arg0 context.Context, arg1 []*v1.Node) (map[types.NamespacedName]*ec2.Instance, error) { +func (m *MockNodeInfoProvider) FetchNodeInstances(arg0 context.Context, arg1 []*v1.Node) (map[types0.NamespacedName]*types.Instance, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "FetchNodeInstances", arg0, arg1) - ret0, _ := ret[0].(map[types.NamespacedName]*ec2.Instance) + ret0, _ := ret[0].(map[types0.NamespacedName]*types.Instance) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/pkg/networking/node_info_provider_test.go b/pkg/networking/node_info_provider_test.go index bf03b87353..ff5b2f5fdd 100644 --- a/pkg/networking/node_info_provider_test.go +++ b/pkg/networking/node_info_provider_test.go @@ -2,10 +2,11 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -20,7 +21,7 @@ import ( func Test_defaultNodeInfoProvider_FetchNodeInstances(t *testing.T) { type describeInstancesAsListCall struct { req *ec2sdk.DescribeInstancesInput - resp []*ec2sdk.Instance + resp []ec2types.Instance err error } type fields struct { @@ -33,7 +34,7 @@ func Test_defaultNodeInfoProvider_FetchNodeInstances(t *testing.T) { name string fields fields args args - want map[types.NamespacedName]*ec2sdk.Instance + want map[types.NamespacedName]*ec2types.Instance wantErr error }{ { @@ -42,9 +43,9 @@ func Test_defaultNodeInfoProvider_FetchNodeInstances(t *testing.T) { describeInstancesAsListCalls: []describeInstancesAsListCall{ { req: &ec2sdk.DescribeInstancesInput{ - InstanceIds: awssdk.StringSlice([]string{"i-0fa2d0064e848c69e", "i-0fa2d0064e848c69f", "i-0fa2d0064e848c69g"}), + InstanceIds: []string{"i-0fa2d0064e848c69e", "i-0fa2d0064e848c69f", "i-0fa2d0064e848c69g"}, }, - resp: []*ec2sdk.Instance{ + resp: []ec2types.Instance{ { InstanceId: awssdk.String("i-0fa2d0064e848c69e"), }, @@ -86,7 +87,7 @@ func Test_defaultNodeInfoProvider_FetchNodeInstances(t *testing.T) { }, }, }, - want: map[types.NamespacedName]*ec2sdk.Instance{ + want: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-1"}: { InstanceId: awssdk.String("i-0fa2d0064e848c69e"), }, @@ -104,7 +105,7 @@ func Test_defaultNodeInfoProvider_FetchNodeInstances(t *testing.T) { describeInstancesAsListCalls: []describeInstancesAsListCall{ { req: &ec2sdk.DescribeInstancesInput{ - InstanceIds: awssdk.StringSlice([]string{"i-0fa2d0064e848c69e", "i-0fa2d0064e848c69f", "i-0fa2d0064e848c69g"}), + InstanceIds: []string{"i-0fa2d0064e848c69e", "i-0fa2d0064e848c69f", "i-0fa2d0064e848c69g"}, }, err: errors.New("some AWS API error"), }, diff --git a/pkg/networking/pod_eni_info_resolver.go b/pkg/networking/pod_eni_info_resolver.go index 3b4a3c064f..a010b58b6e 100644 --- a/pkg/networking/pod_eni_info_resolver.go +++ b/pkg/networking/pod_eni_info_resolver.go @@ -2,8 +2,9 @@ package networking import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -218,7 +219,7 @@ func (r *defaultPodENIInfoResolver) resolveViaPodENIAnnotation(ctx context.Conte eniIDs := sets.StringKeySet(podKeysByENIID).List() req := &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice(eniIDs), + NetworkInterfaceIds: eniIDs, } enis, err := r.ec2Client.DescribeNetworkInterfacesAsList(ctx, req) if err != nil { @@ -226,7 +227,7 @@ func (r *defaultPodENIInfoResolver) resolveViaPodENIAnnotation(ctx context.Conte } eniInfoByPodKey := make(map[types.NamespacedName]ENIInfo) for _, eni := range enis { - eniID := awssdk.StringValue(eni.NetworkInterfaceId) + eniID := awssdk.ToString(eni.NetworkInterfaceId) eniInfo := buildENIInfoViaENI(eni) for _, podKey := range podKeysByENIID[eniID] { eniInfoByPodKey[podKey] = eniInfo @@ -307,7 +308,7 @@ func (r *defaultPodENIInfoResolver) resolveViaVPCENIs(ctx context.Context, pods for _, eni := range eniByID { eniInfo := buildENIInfoViaENI(eni) for _, addr := range eni.PrivateIpAddresses { - eniIP := awssdk.StringValue(addr.PrivateIpAddress) + eniIP := awssdk.ToString(addr.PrivateIpAddress) for _, podKey := range podKeysByIP[eniIP] { eniInfoByPodKey[podKey] = eniInfo } @@ -323,7 +324,7 @@ func (r *defaultPodENIInfoResolver) resolveViaVPCENIs(ctx context.Context, pods for _, eni := range eniByID { eniInfo := buildENIInfoViaENI(eni) for _, addr := range eni.Ipv6Addresses { - eniIPv6 := awssdk.StringValue(addr.Ipv6Address) + eniIPv6 := awssdk.ToString(addr.Ipv6Address) for _, podKey := range podKeysByIP[eniIPv6] { eniInfoByPodKey[podKey] = eniInfo } @@ -333,19 +334,19 @@ func (r *defaultPodENIInfoResolver) resolveViaVPCENIs(ctx context.Context, pods return eniInfoByPodKey, nil } -func (r *defaultPodENIInfoResolver) getENIMappingViaDescribe(ctx context.Context, podIPs []string, ipAddressFilterKey string) (map[string]*ec2sdk.NetworkInterface, error) { +func (r *defaultPodENIInfoResolver) getENIMappingViaDescribe(ctx context.Context, podIPs []string, ipAddressFilterKey string) (map[string]ec2types.NetworkInterface, error) { podIPChunks := algorithm.ChunkStrings(podIPs, r.describeNetworkInterfacesIPChunkSize) - eniByID := make(map[string]*ec2sdk.NetworkInterface) + eniByID := make(map[string]ec2types.NetworkInterface) for _, podIPChunk := range podIPChunks { req := &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{r.vpcID}), + Values: []string{r.vpcID}, }, { Name: awssdk.String(ipAddressFilterKey), - Values: awssdk.StringSlice(podIPChunk), + Values: podIPChunk, }, }, } @@ -354,7 +355,7 @@ func (r *defaultPodENIInfoResolver) getENIMappingViaDescribe(ctx context.Context return nil, err } for _, eni := range enis { - eniID := awssdk.StringValue(eni.NetworkInterfaceId) + eniID := awssdk.ToString(eni.NetworkInterfaceId) eniByID[eniID] = eni } } @@ -362,9 +363,9 @@ func (r *defaultPodENIInfoResolver) getENIMappingViaDescribe(ctx context.Context } // isPodSupportedByNodeENI checks whether pod is supported by specific nodeENI. -func (r *defaultPodENIInfoResolver) isPodSupportedByNodeENI(pod k8s.PodInfo, nodeENI *ec2sdk.InstanceNetworkInterface) bool { +func (r *defaultPodENIInfoResolver) isPodSupportedByNodeENI(pod k8s.PodInfo, nodeENI ec2types.InstanceNetworkInterface) bool { for _, ipv4Address := range nodeENI.PrivateIpAddresses { - if pod.PodIP == awssdk.StringValue(ipv4Address.PrivateIpAddress) { + if pod.PodIP == awssdk.ToString(ipv4Address.PrivateIpAddress) { return true } } @@ -372,12 +373,12 @@ func (r *defaultPodENIInfoResolver) isPodSupportedByNodeENI(pod k8s.PodInfo, nod if len(nodeENI.Ipv4Prefixes) > 0 || len(nodeENI.Ipv6Prefixes) > 0 { if podIP := net.ParseIP(pod.PodIP); podIP != nil { for _, ipv4Prefix := range nodeENI.Ipv4Prefixes { - if _, ipv4CIDR, err := net.ParseCIDR(awssdk.StringValue(ipv4Prefix.Ipv4Prefix)); err == nil && ipv4CIDR.Contains(podIP) { + if _, ipv4CIDR, err := net.ParseCIDR(awssdk.ToString(ipv4Prefix.Ipv4Prefix)); err == nil && ipv4CIDR.Contains(podIP) { return true } } for _, ipv6Prefix := range nodeENI.Ipv6Prefixes { - if _, ipv6CIDR, err := net.ParseCIDR(awssdk.StringValue(ipv6Prefix.Ipv6Prefix)); err == nil && ipv6CIDR.Contains(podIP) { + if _, ipv6CIDR, err := net.ParseCIDR(awssdk.ToString(ipv6Prefix.Ipv6Prefix)); err == nil && ipv6CIDR.Contains(podIP) { return true } } diff --git a/pkg/networking/pod_eni_info_resolver_test.go b/pkg/networking/pod_eni_info_resolver_test.go index c95c502e5f..f9a700d68d 100644 --- a/pkg/networking/pod_eni_info_resolver_test.go +++ b/pkg/networking/pod_eni_info_resolver_test.go @@ -2,10 +2,11 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -30,12 +31,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { ProviderID: "aws:///us-west-2a/i-0fa2d0064e848c69a", }, } - instanceA := &ec2sdk.Instance{ + instanceA := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69a"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.200.1"), }, @@ -43,10 +44,10 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.200.2"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -56,12 +57,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { } type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type env struct { @@ -94,12 +95,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -107,7 +108,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -117,12 +118,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-c", "eni-d"}), + NetworkInterfaceIds: []string{"eni-c", "eni-d"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-c"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-c-1"), }, @@ -130,7 +131,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-d"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-d-1"), }, @@ -232,12 +233,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -245,7 +246,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -255,12 +256,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-c"}), + NetworkInterfaceIds: []string{"eni-c"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-c"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-c-1"), }, @@ -362,12 +363,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -375,7 +376,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -461,12 +462,12 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -474,7 +475,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -486,7 +487,7 @@ func Test_defaultPodENIInfoResolver_Resolve(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, }, }, @@ -587,12 +588,12 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { ProviderID: "aws:///us-west-2a/i-0fa2d0064e848c69a", }, } - instanceA := &ec2sdk.Instance{ + instanceA := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69a"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.200.1"), }, @@ -600,10 +601,10 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.200.2"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -611,7 +612,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.200.3"), }, @@ -619,10 +620,10 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.200.4"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(1), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(1), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -632,12 +633,12 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { } type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type env struct { @@ -667,12 +668,12 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -680,7 +681,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -738,7 +739,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_EC2(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, }, }, @@ -842,12 +843,12 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. } type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type env struct { @@ -877,21 +878,21 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.128.147", "192.168.128.148"}), + Values: []string{"192.168.128.147", "192.168.128.148"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.128.146"), }, @@ -899,7 +900,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. PrivateIpAddress: awssdk.String("192.168.128.147"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -907,7 +908,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. }, { NetworkInterfaceId: awssdk.String("eni-b"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.128.148"), }, @@ -915,7 +916,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. PrivateIpAddress: awssdk.String("192.168.128.149"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -1001,7 +1002,7 @@ func Test_defaultPodENIInfoResolver_resolveViaCascadedLookup_Fargate(t *testing. func Test_defaultPodENIInfoResolver_resolveViaPodENIAnnotation(t *testing.T) { type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fields struct { @@ -1023,12 +1024,12 @@ func Test_defaultPodENIInfoResolver_resolveViaPodENIAnnotation(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a", "eni-b"}), + NetworkInterfaceIds: []string{"eni-a", "eni-b"}, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -1036,7 +1037,7 @@ func Test_defaultPodENIInfoResolver_resolveViaPodENIAnnotation(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -1154,7 +1155,7 @@ func Test_defaultPodENIInfoResolver_resolveViaPodENIAnnotation(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - NetworkInterfaceIds: awssdk.StringSlice([]string{"eni-a"}), + NetworkInterfaceIds: []string{"eni-a"}, }, err: errors.New("eni eni-a not found"), }, @@ -1239,12 +1240,12 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { ProviderID: "aws:///us-west-2b/xxxxxxxx/fargate-ip-192-168-128-147.us-west-2.compute.internal", }, } - instanceA := &ec2sdk.Instance{ + instanceA := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69a"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a-1"), - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.1"), }, @@ -1252,10 +1253,10 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.2"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -1263,20 +1264,20 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { }, }, } - instanceB := &ec2sdk.Instance{ + instanceB := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69b"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b-1"), - Ipv4Prefixes: []*ec2sdk.InstanceIpv4Prefix{ + Ipv4Prefixes: []ec2types.InstanceIpv4Prefix{ { Ipv4Prefix: awssdk.String("192.168.142.128/28"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -1284,12 +1285,12 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { }, }, } - instanceC := &ec2sdk.Instance{ + instanceC := &ec2types.Instance{ InstanceId: awssdk.String("i-0fa2d0064e848c69c"), - NetworkInterfaces: []*ec2sdk.InstanceNetworkInterface{ + NetworkInterfaces: []ec2types.InstanceNetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-c-1"), - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.3"), }, @@ -1297,10 +1298,10 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.4"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-c-1"), }, @@ -1308,15 +1309,15 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-c-2"), - Ipv4Prefixes: []*ec2sdk.InstanceIpv4Prefix{ + Ipv4Prefixes: []ec2types.InstanceIpv4Prefix{ { Ipv4Prefix: awssdk.String("192.168.172.128/28"), }, }, - Attachment: &ec2sdk.InstanceNetworkInterfaceAttachment{ - DeviceIndex: awssdk.Int64(0), + Attachment: &ec2types.InstanceNetworkInterfaceAttachment{ + DeviceIndex: awssdk.Int32(0), }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-c-2"), }, @@ -1329,7 +1330,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { } type fetchNodeInstancesCall struct { nodes []*corev1.Node - nodeInstanceByNodeKey map[types.NamespacedName]*ec2sdk.Instance + nodeInstanceByNodeKey map[types.NamespacedName]*ec2types.Instance err error } type fields struct { @@ -1355,7 +1356,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB, nodeC}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, types.NamespacedName{Name: "node-c"}: instanceC, @@ -1419,7 +1420,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, }, @@ -1468,7 +1469,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB, nodeC}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-c"}: instanceC, }, @@ -1527,7 +1528,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { fetchNodeInstancesCalls: []fetchNodeInstancesCall{ { nodes: []*corev1.Node{nodeA, nodeB, nodeC}, - nodeInstanceByNodeKey: map[types.NamespacedName]*ec2sdk.Instance{ + nodeInstanceByNodeKey: map[types.NamespacedName]*ec2types.Instance{ types.NamespacedName{Name: "node-a"}: instanceA, types.NamespacedName{Name: "node-b"}: instanceB, types.NamespacedName{Name: "node-c"}: instanceC, @@ -1696,7 +1697,7 @@ func Test_defaultPodENIInfoResolver_resolveViaNodeENIs(t *testing.T) { func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fields struct { @@ -1718,21 +1719,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.100.1", "192.168.100.3"}), + Values: []string{"192.168.100.1", "192.168.100.3"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.1"), }, @@ -1740,7 +1741,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.2"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -1748,7 +1749,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.3"), }, @@ -1756,7 +1757,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.4"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -1799,21 +1800,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.100.1", "192.168.100.2"}), + Values: []string{"192.168.100.1", "192.168.100.2"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.1"), }, @@ -1821,7 +1822,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.2"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -1831,22 +1832,22 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { }, { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.100.3", "192.168.100.4"}), + Values: []string{"192.168.100.3", "192.168.100.4"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.3"), }, @@ -1854,7 +1855,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.4"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -1917,21 +1918,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.100.1", "192.168.100.3"}), + Values: []string{"192.168.100.1", "192.168.100.3"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - PrivateIpAddresses: []*ec2sdk.NetworkInterfacePrivateIpAddress{ + PrivateIpAddresses: []ec2types.NetworkInterfacePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.1"), }, @@ -1939,7 +1940,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { PrivateIpAddress: awssdk.String("192.168.100.2"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -1978,14 +1979,14 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("addresses.private-ip-address"), - Values: awssdk.StringSlice([]string{"192.168.100.1", "192.168.100.3"}), + Values: []string{"192.168.100.1", "192.168.100.3"}, }, }, }, @@ -2041,7 +2042,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIs(t *testing.T) { func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { type describeNetworkInterfacesAsListCall struct { req *ec2sdk.DescribeNetworkInterfacesInput - resp []*ec2sdk.NetworkInterface + resp []ec2types.NetworkInterface err error } type fields struct { @@ -2063,21 +2064,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("ipv6-addresses.ipv6-address"), - Values: awssdk.StringSlice([]string{"2001:0db8:85a3:0000:0000:8a2e:0370:ee50", "2001:0db8:85a3:0000:0000:9704:6c49:9e7d"}), + Values: []string{"2001:0db8:85a3:0000:0000:8a2e:0370:ee50", "2001:0db8:85a3:0000:0000:9704:6c49:9e7d"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Ipv6Addresses: []*ec2sdk.NetworkInterfaceIpv6Address{ + Ipv6Addresses: []ec2types.NetworkInterfaceIpv6Address{ { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:8a2e:0370:ee50"), }, @@ -2085,7 +2086,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:8a2e:0370:ee52"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -2093,7 +2094,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { }, { NetworkInterfaceId: awssdk.String("eni-b"), - Ipv6Addresses: []*ec2sdk.NetworkInterfaceIpv6Address{ + Ipv6Addresses: []ec2types.NetworkInterfaceIpv6Address{ { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:9704:6c49:9e70"), }, @@ -2101,7 +2102,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:9704:6c49:9e7d"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -2144,21 +2145,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("ipv6-addresses.ipv6-address"), - Values: awssdk.StringSlice([]string{"2001:0db8:85a3:0000:0000:8a2e:0370:ee50", "2001:0db8:85a3:0000:0000:9704:6c49:9e7d"}), + Values: []string{"2001:0db8:85a3:0000:0000:8a2e:0370:ee50", "2001:0db8:85a3:0000:0000:9704:6c49:9e7d"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Ipv6Addresses: []*ec2sdk.NetworkInterfaceIpv6Address{ + Ipv6Addresses: []ec2types.NetworkInterfaceIpv6Address{ { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:8a2e:0370:ee50"), }, @@ -2166,7 +2167,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:9704:6c49:9e7d"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -2176,21 +2177,21 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { }, { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("ipv6-addresses.ipv6-address"), - Values: awssdk.StringSlice([]string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}), + Values: []string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-b"), - Ipv6Addresses: []*ec2sdk.NetworkInterfaceIpv6Address{ + Ipv6Addresses: []ec2types.NetworkInterfaceIpv6Address{ { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:8493:9af3:a786"), }, @@ -2198,7 +2199,7 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:3f04:39e7:58d9"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-b-1"), }, @@ -2261,26 +2262,26 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("ipv6-addresses.ipv6-address"), - Values: awssdk.StringSlice([]string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}), + Values: []string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}, }, }, }, - resp: []*ec2sdk.NetworkInterface{ + resp: []ec2types.NetworkInterface{ { NetworkInterfaceId: awssdk.String("eni-a"), - Ipv6Addresses: []*ec2sdk.NetworkInterfaceIpv6Address{ + Ipv6Addresses: []ec2types.NetworkInterfaceIpv6Address{ { Ipv6Address: awssdk.String("2001:0db8:85a3:0000:0000:8493:9af3:a786"), }, }, - Groups: []*ec2sdk.GroupIdentifier{ + Groups: []ec2types.GroupIdentifier{ { GroupId: awssdk.String("sg-a-1"), }, @@ -2319,14 +2320,14 @@ func Test_defaultPodENIInfoResolver_resolveViaVPCENIsForIPv6(t *testing.T) { describeNetworkInterfacesAsListCalls: []describeNetworkInterfacesAsListCall{ { req: &ec2sdk.DescribeNetworkInterfacesInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-0d6d9ee10bd062dcc"}), + Values: []string{"vpc-0d6d9ee10bd062dcc"}, }, { Name: awssdk.String("ipv6-addresses.ipv6-address"), - Values: awssdk.StringSlice([]string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}), + Values: []string{"2001:0db8:85a3:0000:0000:8493:9af3:a786", "2001:0db8:85a3:0000:0000:3f04:39e7:58d9"}, }, }, }, @@ -2520,7 +2521,7 @@ func Test_computePodsWithoutENIInfo(t *testing.T) { func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { type args struct { pod k8s.PodInfo - nodeENI *ec2sdk.InstanceNetworkInterface + nodeENI ec2types.InstanceNetworkInterface } tests := []struct { name string @@ -2533,8 +2534,8 @@ func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { pod: k8s.PodInfo{ PodIP: "192.168.100.23", }, - nodeENI: &ec2sdk.InstanceNetworkInterface{ - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + nodeENI: ec2types.InstanceNetworkInterface{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.22"), }, @@ -2552,8 +2553,8 @@ func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { pod: k8s.PodInfo{ PodIP: "192.168.100.21", }, - nodeENI: &ec2sdk.InstanceNetworkInterface{ - PrivateIpAddresses: []*ec2sdk.InstancePrivateIpAddress{ + nodeENI: ec2types.InstanceNetworkInterface{ + PrivateIpAddresses: []ec2types.InstancePrivateIpAddress{ { PrivateIpAddress: awssdk.String("192.168.100.22"), }, @@ -2571,8 +2572,8 @@ func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { pod: k8s.PodInfo{ PodIP: "192.168.172.140", }, - nodeENI: &ec2sdk.InstanceNetworkInterface{ - Ipv4Prefixes: []*ec2sdk.InstanceIpv4Prefix{ + nodeENI: ec2types.InstanceNetworkInterface{ + Ipv4Prefixes: []ec2types.InstanceIpv4Prefix{ { Ipv4Prefix: awssdk.String("192.168.197.64/28"), }, @@ -2590,8 +2591,8 @@ func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { pod: k8s.PodInfo{ PodIP: "192.168.100.23", }, - nodeENI: &ec2sdk.InstanceNetworkInterface{ - Ipv4Prefixes: []*ec2sdk.InstanceIpv4Prefix{ + nodeENI: ec2types.InstanceNetworkInterface{ + Ipv4Prefixes: []ec2types.InstanceIpv4Prefix{ { Ipv4Prefix: awssdk.String("192.168.197.64/28"), }, @@ -2609,8 +2610,8 @@ func Test_defaultPodENIInfoResolver_isPodSupportedByNodeENI(t *testing.T) { pod: k8s.PodInfo{ PodIP: "abcdefg", }, - nodeENI: &ec2sdk.InstanceNetworkInterface{ - Ipv4Prefixes: []*ec2sdk.InstanceIpv4Prefix{ + nodeENI: ec2types.InstanceNetworkInterface{ + Ipv4Prefixes: []ec2types.InstanceIpv4Prefix{ { Ipv4Prefix: awssdk.String("192.168.197.64/28"), }, diff --git a/pkg/networking/security_group_info.go b/pkg/networking/security_group_info.go index 20879cfd35..69db125138 100644 --- a/pkg/networking/security_group_info.go +++ b/pkg/networking/security_group_info.go @@ -3,8 +3,8 @@ package networking import ( "encoding/json" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "k8s.io/apimachinery/pkg/util/sets" "regexp" "strings" @@ -29,7 +29,7 @@ type SecurityGroupInfo struct { type IPPermissionInfo struct { // the aws sdk permission - Permission ec2sdk.IpPermission + Permission ec2types.IpPermission // a set of computed labels for IPPermission. // we can use labels to select the rules we want to manage. @@ -39,24 +39,24 @@ type IPPermissionInfo struct { // HashCode returns the hashcode for the IPPermissionInfo. // The hashCode should only include the actual permission but not labels/descriptions. func (perm *IPPermissionInfo) HashCode() string { - protocol := awssdk.StringValue(perm.Permission.IpProtocol) - fromPort := awssdk.Int64Value(perm.Permission.FromPort) - toPort := awssdk.Int64Value(perm.Permission.ToPort) + protocol := awssdk.ToString(perm.Permission.IpProtocol) + fromPort := awssdk.ToInt32(perm.Permission.FromPort) + toPort := awssdk.ToInt32(perm.Permission.ToPort) base := fmt.Sprintf("IpProtocol: %v, FromPort: %v, ToPort: %v", protocol, fromPort, toPort) if len(perm.Permission.IpRanges) == 1 { - cidrIP := awssdk.StringValue(perm.Permission.IpRanges[0].CidrIp) + cidrIP := awssdk.ToString(perm.Permission.IpRanges[0].CidrIp) return fmt.Sprintf("%v, IpRange: %v", base, cidrIP) } if len(perm.Permission.Ipv6Ranges) == 1 { - cidrIPv6 := awssdk.StringValue(perm.Permission.Ipv6Ranges[0].CidrIpv6) + cidrIPv6 := awssdk.ToString(perm.Permission.Ipv6Ranges[0].CidrIpv6) return fmt.Sprintf("%v, Ipv6Range: %v", base, cidrIPv6) } if len(perm.Permission.PrefixListIds) == 1 { - prefixListID := awssdk.StringValue(perm.Permission.PrefixListIds[0].PrefixListId) + prefixListID := awssdk.ToString(perm.Permission.PrefixListIds[0].PrefixListId) return fmt.Sprintf("%v, PrefixListId: %v", base, prefixListID) } if len(perm.Permission.UserIdGroupPairs) == 1 { - groupID := awssdk.StringValue(perm.Permission.UserIdGroupPairs[0].GroupId) + groupID := awssdk.ToString(perm.Permission.UserIdGroupPairs[0].GroupId) return fmt.Sprintf("%v, UserIdGroupPair: %v", base, groupID) } @@ -66,11 +66,11 @@ func (perm *IPPermissionInfo) HashCode() string { } // NewRawSecurityGroupInfo constructs new SecurityGroupInfo with raw ec2SDK's SecurityGroup object. -func NewRawSecurityGroupInfo(sdkSG *ec2sdk.SecurityGroup) SecurityGroupInfo { - sgID := awssdk.StringValue(sdkSG.GroupId) +func NewRawSecurityGroupInfo(sdkSG ec2types.SecurityGroup) SecurityGroupInfo { + sgID := awssdk.ToString(sdkSG.GroupId) var ingress []IPPermissionInfo for _, sdkPermission := range sdkSG.IpPermissions { - for _, expandedPermission := range expandSDKIPPermission(*sdkPermission) { + for _, expandedPermission := range expandSDKIPPermission(sdkPermission) { ingress = append(ingress, NewRawIPPermission(expandedPermission)) } } @@ -83,14 +83,14 @@ func NewRawSecurityGroupInfo(sdkSG *ec2sdk.SecurityGroup) SecurityGroupInfo { } // NewCIDRIPPermission constructs new IPPermissionInfo with CIDR configuration. -func NewCIDRIPPermission(ipProtocol string, fromPort *int64, toPort *int64, cidr string, labels map[string]string) IPPermissionInfo { +func NewCIDRIPPermission(ipProtocol string, fromPort *int32, toPort *int32, cidr string, labels map[string]string) IPPermissionInfo { description := buildIPPermissionDescriptionForLabels(labels) return IPPermissionInfo{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String(ipProtocol), FromPort: fromPort, ToPort: toPort, - IpRanges: []*ec2sdk.IpRange{ + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String(cidr), Description: awssdk.String(description), @@ -102,14 +102,14 @@ func NewCIDRIPPermission(ipProtocol string, fromPort *int64, toPort *int64, cidr } // NewCIDRv6IPPermission constructs new IPPermissionInfo with CIDRv6 configuration. -func NewCIDRv6IPPermission(ipProtocol string, fromPort *int64, toPort *int64, cidrV6 string, labels map[string]string) IPPermissionInfo { +func NewCIDRv6IPPermission(ipProtocol string, fromPort *int32, toPort *int32, cidrV6 string, labels map[string]string) IPPermissionInfo { description := buildIPPermissionDescriptionForLabels(labels) return IPPermissionInfo{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String(ipProtocol), FromPort: fromPort, ToPort: toPort, - Ipv6Ranges: []*ec2sdk.Ipv6Range{ + Ipv6Ranges: []ec2types.Ipv6Range{ { CidrIpv6: awssdk.String(cidrV6), Description: awssdk.String(description), @@ -121,14 +121,14 @@ func NewCIDRv6IPPermission(ipProtocol string, fromPort *int64, toPort *int64, ci } // NewCIDRv6IPPermission constructs new IPPermissionInfo with groupID configuration. -func NewGroupIDIPPermission(ipProtocol string, fromPort *int64, toPort *int64, groupID string, labels map[string]string) IPPermissionInfo { +func NewGroupIDIPPermission(ipProtocol string, fromPort *int32, toPort *int32, groupID string, labels map[string]string) IPPermissionInfo { description := buildIPPermissionDescriptionForLabels(labels) return IPPermissionInfo{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String(ipProtocol), FromPort: fromPort, ToPort: toPort, - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { GroupId: awssdk.String(groupID), Description: awssdk.String(description), @@ -140,14 +140,14 @@ func NewGroupIDIPPermission(ipProtocol string, fromPort *int64, toPort *int64, g } // NewPrefixListIDPermission constructs new IPPermissionInfo with prefixListID configuration -func NewPrefixListIDPermission(ipProtocol string, fromPort *int64, toPort *int64, prefixListID string, labels map[string]string) IPPermissionInfo { +func NewPrefixListIDPermission(ipProtocol string, fromPort *int32, toPort *int32, prefixListID string, labels map[string]string) IPPermissionInfo { description := buildIPPermissionDescriptionForLabels(labels) return IPPermissionInfo{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String(ipProtocol), FromPort: fromPort, ToPort: toPort, - PrefixListIds: []*ec2sdk.PrefixListId{ + PrefixListIds: []ec2types.PrefixListId{ { PrefixListId: awssdk.String(prefixListID), Description: awssdk.String(description), @@ -160,29 +160,29 @@ func NewPrefixListIDPermission(ipProtocol string, fromPort *int64, toPort *int64 // NewRawIPPermission constructs new IPPermissionInfo with raw ec2SDK's IpPermission object. // Note: this IpPermission should be expanded(i.e. only contains one source configuration) -func NewRawIPPermission(sdkPermission ec2sdk.IpPermission) IPPermissionInfo { +func NewRawIPPermission(sdkPermission ec2types.IpPermission) IPPermissionInfo { if len(sdkPermission.IpRanges) == 1 { return IPPermissionInfo{ Permission: sdkPermission, - Labels: buildIPPermissionLabelsForDescription(awssdk.StringValue(sdkPermission.IpRanges[0].Description)), + Labels: buildIPPermissionLabelsForDescription(awssdk.ToString(sdkPermission.IpRanges[0].Description)), } } if len(sdkPermission.Ipv6Ranges) == 1 { return IPPermissionInfo{ Permission: sdkPermission, - Labels: buildIPPermissionLabelsForDescription(awssdk.StringValue(sdkPermission.Ipv6Ranges[0].Description)), + Labels: buildIPPermissionLabelsForDescription(awssdk.ToString(sdkPermission.Ipv6Ranges[0].Description)), } } if len(sdkPermission.PrefixListIds) == 1 { return IPPermissionInfo{ Permission: sdkPermission, - Labels: buildIPPermissionLabelsForDescription(awssdk.StringValue(sdkPermission.PrefixListIds[0].Description)), + Labels: buildIPPermissionLabelsForDescription(awssdk.ToString(sdkPermission.PrefixListIds[0].Description)), } } if len(sdkPermission.UserIdGroupPairs) == 1 { return IPPermissionInfo{ Permission: sdkPermission, - Labels: buildIPPermissionLabelsForDescription(awssdk.StringValue(sdkPermission.UserIdGroupPairs[0].Description)), + Labels: buildIPPermissionLabelsForDescription(awssdk.ToString(sdkPermission.UserIdGroupPairs[0].Description)), } } return IPPermissionInfo{ @@ -197,19 +197,19 @@ func NewIPPermissionLabelsForRawDescription(description string) map[string]strin } // buildSecurityGroupTags generates the tags for securityGroup. -func buildSecurityGroupTags(sdkSG *ec2sdk.SecurityGroup) map[string]string { +func buildSecurityGroupTags(sdkSG ec2types.SecurityGroup) map[string]string { sgTags := make(map[string]string, len(sdkSG.Tags)) for _, tag := range sdkSG.Tags { - sgTags[awssdk.StringValue(tag.Key)] = awssdk.StringValue(tag.Value) + sgTags[awssdk.ToString(tag.Key)] = awssdk.ToString(tag.Value) } return sgTags } // expandSDKIPPermission will expand the IPPermission so that each permission only contain single entry. // EC2 api automatically group IPPermissions, so we need to expand first before further processing. -func expandSDKIPPermission(sdkPermission ec2sdk.IpPermission) []ec2sdk.IpPermission { - var expandedPermissions []ec2sdk.IpPermission - base := ec2sdk.IpPermission{ +func expandSDKIPPermission(sdkPermission ec2types.IpPermission) []ec2types.IpPermission { + var expandedPermissions []ec2types.IpPermission + base := ec2types.IpPermission{ FromPort: sdkPermission.FromPort, ToPort: sdkPermission.ToPort, IpProtocol: sdkPermission.IpProtocol, @@ -217,25 +217,25 @@ func expandSDKIPPermission(sdkPermission ec2sdk.IpPermission) []ec2sdk.IpPermiss for _, ipRange := range sdkPermission.IpRanges { perm := base - perm.IpRanges = []*ec2sdk.IpRange{ipRange} + perm.IpRanges = []ec2types.IpRange{ipRange} expandedPermissions = append(expandedPermissions, perm) } for _, ipRange := range sdkPermission.Ipv6Ranges { perm := base - perm.Ipv6Ranges = []*ec2sdk.Ipv6Range{ipRange} + perm.Ipv6Ranges = []ec2types.Ipv6Range{ipRange} expandedPermissions = append(expandedPermissions, perm) } for _, prefixListID := range sdkPermission.PrefixListIds { perm := base - perm.PrefixListIds = []*ec2sdk.PrefixListId{prefixListID} + perm.PrefixListIds = []ec2types.PrefixListId{prefixListID} expandedPermissions = append(expandedPermissions, perm) } for _, ug := range sdkPermission.UserIdGroupPairs { perm := base - perm.UserIdGroupPairs = []*ec2sdk.UserIdGroupPair{ug} + perm.UserIdGroupPairs = []ec2types.UserIdGroupPair{ug} expandedPermissions = append(expandedPermissions, perm) } diff --git a/pkg/networking/security_group_info_test.go b/pkg/networking/security_group_info_test.go index 8cfbbc7af4..4137930143 100644 --- a/pkg/networking/security_group_info_test.go +++ b/pkg/networking/security_group_info_test.go @@ -1,15 +1,15 @@ package networking import ( - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/stretchr/testify/assert" "testing" ) func TestIPPermissionInfo_HashCode(t *testing.T) { type fields struct { - Permission ec2sdk.IpPermission + Permission ec2types.IpPermission Labels map[string]string } tests := []struct { @@ -20,11 +20,11 @@ func TestIPPermissionInfo_HashCode(t *testing.T) { { name: "IpRange permission", fields: fields{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -36,11 +36,11 @@ func TestIPPermissionInfo_HashCode(t *testing.T) { { name: "Ipv6Range permission", fields: fields{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - Ipv6Ranges: []*ec2sdk.Ipv6Range{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + Ipv6Ranges: []ec2types.Ipv6Range{ { CidrIpv6: awssdk.String("::/0"), }, @@ -52,11 +52,11 @@ func TestIPPermissionInfo_HashCode(t *testing.T) { { name: "PrefixListId permission", fields: fields{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - PrefixListIds: []*ec2sdk.PrefixListId{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + PrefixListIds: []ec2types.PrefixListId{ { PrefixListId: awssdk.String("pl-123456abcde123456"), }, @@ -68,11 +68,11 @@ func TestIPPermissionInfo_HashCode(t *testing.T) { { name: "UserIdGroupPair permission", fields: fields{ - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { GroupId: awssdk.String("sg-xxxx"), }, diff --git a/pkg/networking/security_group_manager.go b/pkg/networking/security_group_manager.go index 8cbae59fe8..c90ba36cb3 100644 --- a/pkg/networking/security_group_manager.go +++ b/pkg/networking/security_group_manager.go @@ -2,8 +2,9 @@ package networking import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/cache" @@ -97,7 +98,7 @@ func (m *defaultSecurityGroupManager) FetchSGInfosByID(ctx context.Context, sgID unFetchedSGIDs := sgIDsSet.Difference(fetchedSGIDsSet).List() if len(unFetchedSGIDs) > 0 { req := &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice(unFetchedSGIDs), + GroupIds: unFetchedSGIDs, } sgInfoByIDFromAWS, err := m.fetchSGInfosFromAWS(ctx, req) if err != nil { @@ -200,7 +201,7 @@ func (m *defaultSecurityGroupManager) fetchSGInfosFromAWS(ctx context.Context, r } sgInfoByID := make(map[string]SecurityGroupInfo, len(sgs)) for _, sg := range sgs { - sgID := awssdk.StringValue(sg.GroupId) + sgID := awssdk.ToString(sg.GroupId) sgInfo := NewRawSecurityGroupInfo(sg) sgInfoByID[sgID] = sgInfo } @@ -209,13 +210,13 @@ func (m *defaultSecurityGroupManager) fetchSGInfosFromAWS(ctx context.Context, r // buildSDKIPPermissions converts slice of IPPermissionInfo into slice of pointers to IPPermission // if targets is empty or nil, nil will be returned. -func buildSDKIPPermissions(permissions []IPPermissionInfo) []*ec2sdk.IpPermission { +func buildSDKIPPermissions(permissions []IPPermissionInfo) []ec2types.IpPermission { if len(permissions) == 0 { return nil } - sdkPermissions := make([]*ec2sdk.IpPermission, 0, len(permissions)) + sdkPermissions := make([]ec2types.IpPermission, 0, len(permissions)) for i := range permissions { - sdkPermissions = append(sdkPermissions, &permissions[i].Permission) + sdkPermissions = append(sdkPermissions, permissions[i].Permission) } return sdkPermissions } diff --git a/pkg/networking/security_group_manager_mocks.go b/pkg/networking/security_group_manager_mocks.go index 5f44578549..dfb496eae9 100644 --- a/pkg/networking/security_group_manager_mocks.go +++ b/pkg/networking/security_group_manager_mocks.go @@ -8,7 +8,7 @@ import ( context "context" reflect "reflect" - ec2 "github.com/aws/aws-sdk-go/service/ec2" + ec2 "github.com/aws/aws-sdk-go-v2/service/ec2" gomock "github.com/golang/mock/gomock" ) diff --git a/pkg/networking/security_group_reconciler.go b/pkg/networking/security_group_reconciler.go index ea1ea104b6..8b9e5731f5 100644 --- a/pkg/networking/security_group_reconciler.go +++ b/pkg/networking/security_group_reconciler.go @@ -2,7 +2,7 @@ package networking import ( "context" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/smithy-go" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/labels" @@ -117,9 +117,9 @@ func (r *defaultSecurityGroupReconciler) reconcileIngressWithSGInfo(ctx context. // shouldRetryWithoutCache tests whether we should retry SecurityGroup rules reconcile without cache. func (r *defaultSecurityGroupReconciler) shouldRetryWithoutCache(err error) bool { - var awsErr awserr.Error - if errors.As(err, &awsErr) { - return awsErr.Code() == "InvalidPermission.Duplicate" || awsErr.Code() == "InvalidPermission.NotFound" + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + return apiErr.ErrorCode() == "InvalidPermission.Duplicate" || apiErr.ErrorCode() == "InvalidPermission.NotFound" } return false } diff --git a/pkg/networking/security_group_reconciler_test.go b/pkg/networking/security_group_reconciler_test.go index 0a2271309f..2bb3c71247 100644 --- a/pkg/networking/security_group_reconciler_test.go +++ b/pkg/networking/security_group_reconciler_test.go @@ -1,9 +1,9 @@ package networking import ( - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go" "github.com/stretchr/testify/assert" "testing" ) @@ -20,21 +20,21 @@ func Test_defaultSecurityGroupReconciler_shouldRetryWithoutCache(t *testing.T) { { name: "should retry without cache when got duplicated permission error", args: args{ - err: awserr.New("InvalidPermission.Duplicate", "", nil), + err: &smithy.GenericAPIError{Code: "InvalidPermission.Duplicate", Message: ""}, }, want: true, }, { name: "should retry without cache when got not found permission error", args: args{ - err: awserr.New("InvalidPermission.NotFound", "", nil), + err: &smithy.GenericAPIError{Code: "InvalidPermission.NotFound", Message: ""}, }, want: true, }, { name: "shouldn't retry when got some other error", args: args{ - err: awserr.New("SomeOtherError", "", nil), + err: &smithy.GenericAPIError{Code: "SomeOtherError", Message: ""}, }, want: false, }, @@ -63,11 +63,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { args: args{ source: []IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -75,11 +75,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.171.0.0/16"), }, @@ -87,11 +87,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -101,11 +101,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, target: []IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -113,11 +113,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -128,11 +128,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, want: []IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.171.0.0/16"), }, @@ -146,11 +146,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { args: args{ source: []IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -158,11 +158,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -172,11 +172,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, target: []IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -184,11 +184,11 @@ func Test_diffIPPermissionInfos(t *testing.T) { }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, diff --git a/pkg/networking/security_group_resolver.go b/pkg/networking/security_group_resolver.go index 3b807729d6..bf24e1f522 100644 --- a/pkg/networking/security_group_resolver.go +++ b/pkg/networking/security_group_resolver.go @@ -2,12 +2,13 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/pkg/errors" - "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" ) @@ -34,7 +35,7 @@ type defaultSecurityGroupResolver struct { } func (r *defaultSecurityGroupResolver) ResolveViaNameOrID(ctx context.Context, sgNameOrIDs []string) ([]string, error) { - var resolvedSGs []*ec2sdk.SecurityGroup + var resolvedSGs []ec2types.SecurityGroup var errMessages []string sgIDs, sgNames := r.splitIntoSgNameAndIDs(sgNameOrIDs) @@ -63,15 +64,15 @@ func (r *defaultSecurityGroupResolver) ResolveViaNameOrID(ctx context.Context, s resolvedSGIDs := make([]string, 0, len(resolvedSGs)) for _, sg := range resolvedSGs { - resolvedSGIDs = append(resolvedSGIDs, awssdk.StringValue(sg.GroupId)) + resolvedSGIDs = append(resolvedSGIDs, awssdk.ToString(sg.GroupId)) } return resolvedSGIDs, nil } -func (r *defaultSecurityGroupResolver) resolveViaGroupID(ctx context.Context, sgIDs []string) ([]*ec2sdk.SecurityGroup, error) { +func (r *defaultSecurityGroupResolver) resolveViaGroupID(ctx context.Context, sgIDs []string) ([]ec2types.SecurityGroup, error) { req := &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice(sgIDs), + GroupIds: sgIDs, } sgs, err := r.ec2Client.DescribeSecurityGroupsAsList(ctx, req) @@ -81,7 +82,7 @@ func (r *defaultSecurityGroupResolver) resolveViaGroupID(ctx context.Context, sg resolvedSGIDs := make([]string, 0, len(sgs)) for _, sg := range sgs { - resolvedSGIDs = append(resolvedSGIDs, awssdk.StringValue(sg.GroupId)) + resolvedSGIDs = append(resolvedSGIDs, awssdk.ToString(sg.GroupId)) } if len(sgIDs) != len(resolvedSGIDs) { @@ -91,18 +92,18 @@ func (r *defaultSecurityGroupResolver) resolveViaGroupID(ctx context.Context, sg return sgs, nil } -func (r *defaultSecurityGroupResolver) resolveViaGroupName(ctx context.Context, sgNames []string) ([]*ec2sdk.SecurityGroup, error) { +func (r *defaultSecurityGroupResolver) resolveViaGroupName(ctx context.Context, sgNames []string) ([]ec2types.SecurityGroup, error) { sgNames = algorithm.RemoveSliceDuplicates(sgNames) req := &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice(sgNames), + Values: sgNames, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{r.vpcID}), + Values: []string{r.vpcID}, }, }, } @@ -115,8 +116,8 @@ func (r *defaultSecurityGroupResolver) resolveViaGroupName(ctx context.Context, resolvedSGNames := make([]string, 0, len(sgs)) for _, sg := range sgs { for _, tag := range sg.Tags { - if awssdk.StringValue(tag.Key) == "Name" { - resolvedSGNames = append(resolvedSGNames, awssdk.StringValue(tag.Value)) + if awssdk.ToString(tag.Key) == "Name" { + resolvedSGNames = append(resolvedSGNames, awssdk.ToString(tag.Value)) } } } diff --git a/pkg/networking/security_group_resolver_test.go b/pkg/networking/security_group_resolver_test.go index bd2c663c50..eb20242178 100644 --- a/pkg/networking/security_group_resolver_test.go +++ b/pkg/networking/security_group_resolver_test.go @@ -2,11 +2,12 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + "github.com/aws/smithy-go" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/golang/mock/gomock" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -16,7 +17,7 @@ import ( func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { type describeSecurityGroupsAsListCall struct { req *ec2sdk.DescribeSecurityGroupsInput - resp []*ec2sdk.SecurityGroup + resp []ec2types.SecurityGroup err error } type args struct { @@ -43,9 +44,9 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice([]string{"sg-xx1", "sg-xx2"}), + GroupIds: []string{"sg-xx1", "sg-xx2"}, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-xx1"), }, @@ -71,30 +72,30 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{ + Values: []string{ "sg group one", "sg group two", - }), + }, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-0912f63b"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group one")}, }, }, { GroupId: awssdk.String("sg-08982de7"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group two")}, }, }, @@ -116,29 +117,29 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{ + Values: []string{ "sg group one", - }), + }, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-id1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group one")}, }, }, { GroupId: awssdk.String("sg-id2"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group one")}, }, }, @@ -161,23 +162,23 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{ + Values: []string{ "sg group one", - }), + }, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-0912f63b"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group one")}, }, }, @@ -185,9 +186,9 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { }, { req: &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice([]string{"sg-id1"}), + GroupIds: []string{"sg-id1"}, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-id1"), }, @@ -209,13 +210,13 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice([]string{"sg-id"}), + GroupIds: []string{"sg-id"}, }, - err: awserr.New("Describe.Error", "unable to describe security groups", nil), + err: &smithy.GenericAPIError{Code: "Describe.Error", Message: "unable to describe security groups"}, }, }, }, - wantErr: errors.New("couldn't find all security groups: Describe.Error: unable to describe security groups"), + wantErr: errors.New("couldn't find all security groups: api error Describe.Error: unable to describe security groups"), }, { name: "describe by name returns error", @@ -226,22 +227,22 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{"sg group name"}), + Values: []string{"sg group name"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - err: awserr.New("Describe.Error", "unable to describe security groups", nil), + err: &smithy.GenericAPIError{Code: "Describe.Error", Message: "unable to describe security groups"}, }, }, }, - wantErr: errors.New("couldn't find all security groups: Describe.Error: unable to describe security groups"), + wantErr: errors.New("couldn't find all security groups: api error Describe.Error: unable to describe security groups"), }, { name: "unable to resolve security groups by id", @@ -253,9 +254,9 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice([]string{"sg-id1", "sg-id404"}), + GroupIds: []string{"sg-id1", "sg-id404"}, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-id1"), }, @@ -275,24 +276,24 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{ + Values: []string{ "sg group one", "sg group two", - }), + }, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - resp: []*ec2sdk.SecurityGroup{ + resp: []ec2types.SecurityGroup{ { GroupId: awssdk.String("sg-0912f63b"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ {Key: awssdk.String("Name"), Value: awssdk.String("sg group one")}, }, }, @@ -312,24 +313,24 @@ func Test_defaultSecurityGroupResolver_ResolveViaNameOrID(t *testing.T) { describeSGCalls: []describeSecurityGroupsAsListCall{ { req: &ec2sdk.DescribeSecurityGroupsInput{ - GroupIds: awssdk.StringSlice([]string{"sg-08982de7"}), + GroupIds: []string{"sg-08982de7"}, }, - resp: []*ec2sdk.SecurityGroup{}, + resp: []ec2types.SecurityGroup{}, }, { req: &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{"sg group one"}), + Values: []string{"sg group one"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{defaultVPCID}), + Values: []string{defaultVPCID}, }, }, }, - resp: []*ec2sdk.SecurityGroup{}, + resp: []ec2types.SecurityGroup{}, }, }, }, diff --git a/pkg/networking/subnet_resolver.go b/pkg/networking/subnet_resolver.go index 5186299d77..aba7fba313 100644 --- a/pkg/networking/subnet_resolver.go +++ b/pkg/networking/subnet_resolver.go @@ -3,11 +3,12 @@ package networking import ( "context" "fmt" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "sort" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/util/sets" @@ -45,7 +46,7 @@ type SubnetsResolveOptions struct { // By default, it's internet-facing. LBScheme elbv2model.LoadBalancerScheme // count of available ip addresses - AvailableIPAddressCount int64 + AvailableIPAddressCount int32 // whether to check the cluster tag SubnetsClusterTagCheck bool // whether to allow using only 1 subnet for provisioning ALB, default to false @@ -84,7 +85,7 @@ func WithSubnetsResolveLBScheme(lbScheme elbv2model.LoadBalancerScheme) SubnetsR } // WithSubnetsResolveAvailableIPAddressCount generates an option that configures AvailableIPAddressCount. -func WithSubnetsResolveAvailableIPAddressCount(AvailableIPAddressCount int64) SubnetsResolveOption { +func WithSubnetsResolveAvailableIPAddressCount(AvailableIPAddressCount int32) SubnetsResolveOption { return func(opts *SubnetsResolveOptions) { opts.AvailableIPAddressCount = AvailableIPAddressCount } @@ -113,13 +114,13 @@ type SubnetsResolver interface { // * if SubnetsClusterTagCheck is enabled, subnets within the clusterVPC must contain no cluster tag at all // or contain the "kubernetes.io/cluster/" tag for the current cluster // If multiple subnets are found for specific AZ, one subnet is chosen based on the lexical order of subnetID. - ResolveViaDiscovery(ctx context.Context, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) + ResolveViaDiscovery(ctx context.Context, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) // ResolveViaSelector resolves subnets using a SubnetSelector. - ResolveViaSelector(ctx context.Context, selector *elbv2api.SubnetSelector, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) + ResolveViaSelector(ctx context.Context, selector *elbv2api.SubnetSelector, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) // ResolveViaNameOrIDSlice resolve subnets using subnet name or ID. - ResolveViaNameOrIDSlice(ctx context.Context, subnetNameOrIDs []string, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) + ResolveViaNameOrIDSlice(ctx context.Context, subnetNameOrIDs []string, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) } // NewDefaultSubnetsResolver constructs new defaultSubnetsResolver. @@ -144,7 +145,7 @@ type defaultSubnetsResolver struct { logger logr.Logger } -func (r *defaultSubnetsResolver) ResolveViaDiscovery(ctx context.Context, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) { +func (r *defaultSubnetsResolver) ResolveViaDiscovery(ctx context.Context, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) { resolveOpts := defaultSubnetsResolveOptions() resolveOpts.ApplyOptions(opts) @@ -163,20 +164,20 @@ func (r *defaultSubnetsResolver) ResolveViaDiscovery(ctx context.Context, opts . }, opts...) } -func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selector *elbv2api.SubnetSelector, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) { +func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selector *elbv2api.SubnetSelector, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) { resolveOpts := defaultSubnetsResolveOptions() resolveOpts.ApplyOptions(opts) - var chosenSubnets []*ec2sdk.Subnet + var chosenSubnets []ec2types.Subnet var err error var explanation string if selector.IDs != nil { req := &ec2sdk.DescribeSubnetsInput{ - SubnetIds: make([]*string, 0, len(selector.IDs)), + SubnetIds: make([]string, 0, len(selector.IDs)), } for _, subnetID := range selector.IDs { id := string(subnetID) - req.SubnetIds = append(req.SubnetIds, &id) + req.SubnetIds = append(req.SubnetIds, id) } chosenSubnets, err = r.ec2Client.DescribeSubnetsAsList(ctx, req) if err != nil { @@ -191,10 +192,10 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto // todo validate here? } else { req := &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{r.vpcID}), + Values: []string{r.vpcID}, }, }, } @@ -202,9 +203,9 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto targetTagKeys := []string{} for key, values := range selector.Tags { targetTagKeys = append(targetTagKeys, key) - req.Filters = append(req.Filters, &ec2sdk.Filter{ + req.Filters = append(req.Filters, ec2types.Filter{ Name: awssdk.String("tag:" + key), - Values: awssdk.StringSlice(values), + Values: values, }) } @@ -214,7 +215,7 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto } explanation = fmt.Sprintf("%d match VPC and tags: %s", len(allSubnets), targetTagKeys) - var subnets []*ec2sdk.Subnet + var subnets []ec2types.Subnet taggedOtherCluster := 0 for _, subnet := range allSubnets { if r.checkSubnetIsNotTaggedForOtherClusters(subnet, resolveOpts.SubnetsClusterTagCheck) { @@ -231,7 +232,7 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto explanation += fmt.Sprintf(", %d have fewer than %d free IPs", insufficientIPs, resolveOpts.AvailableIPAddressCount) } subnetsByAZ := mapSDKSubnetsByAZ(filteredSubnets) - chosenSubnets = make([]*ec2sdk.Subnet, 0, len(subnetsByAZ)) + chosenSubnets = make([]ec2types.Subnet, 0, len(subnetsByAZ)) for az, subnets := range subnetsByAZ { if len(subnets) == 1 { chosenSubnets = append(chosenSubnets, subnets[0]) @@ -245,7 +246,7 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto } return false } - return awssdk.StringValue(subnets[i].SubnetId) < awssdk.StringValue(subnets[j].SubnetId) + return awssdk.ToString(subnets[i].SubnetId) < awssdk.ToString(subnets[j].SubnetId) }) r.logger.Info("multiple subnet in the same AvailabilityZone", "AvailabilityZone", az, "chosen", subnets[0].SubnetId, "ignored", subnets[1:]) @@ -267,7 +268,7 @@ func (r *defaultSubnetsResolver) ResolveViaSelector(ctx context.Context, selecto return chosenSubnets, nil } -func (r *defaultSubnetsResolver) ResolveViaNameOrIDSlice(ctx context.Context, subnetNameOrIDs []string, opts ...SubnetsResolveOption) ([]*ec2sdk.Subnet, error) { +func (r *defaultSubnetsResolver) ResolveViaNameOrIDSlice(ctx context.Context, subnetNameOrIDs []string, opts ...SubnetsResolveOption) ([]ec2types.Subnet, error) { resolveOpts := defaultSubnetsResolveOptions() resolveOpts.ApplyOptions(opts) @@ -280,10 +281,10 @@ func (r *defaultSubnetsResolver) ResolveViaNameOrIDSlice(ctx context.Context, su subnetNames = append(subnetNames, nameOrID) } } - var resolvedSubnets []*ec2sdk.Subnet + var resolvedSubnets []ec2types.Subnet if len(subnetIDs) > 0 { req := &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice(subnetIDs), + SubnetIds: subnetIDs, } subnets, err := r.ec2Client.DescribeSubnetsAsList(ctx, req) if err != nil { @@ -294,14 +295,14 @@ func (r *defaultSubnetsResolver) ResolveViaNameOrIDSlice(ctx context.Context, su if len(subnetNames) > 0 { req := &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice(subnetNames), + Values: subnetNames, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{r.vpcID}), + Values: []string{r.vpcID}, }, }, } @@ -333,13 +334,13 @@ func (r *defaultSubnetsResolver) ResolveViaNameOrIDSlice(ctx context.Context, su // validateSDKSubnetsAZExclusivity validates subnets belong to different AZs. // subnets passed-in must be non-empty -func (r *defaultSubnetsResolver) validateSubnetsAZExclusivity(subnets []*ec2sdk.Subnet) error { +func (r *defaultSubnetsResolver) validateSubnetsAZExclusivity(subnets []ec2types.Subnet) error { subnetsByAZ := mapSDKSubnetsByAZ(subnets) for az, subnets := range subnetsByAZ { if len(subnets) > 1 { subnetIDs := make([]string, 0, len(subnets)) for _, subnet := range subnets { - subnetIDs = append(subnetIDs, awssdk.StringValue(subnet.SubnetId)) + subnetIDs = append(subnetIDs, awssdk.ToString(subnet.SubnetId)) } return errors.Errorf("multiple subnets in same Availability Zone %v: %v", az, subnetIDs) } @@ -349,7 +350,7 @@ func (r *defaultSubnetsResolver) validateSubnetsAZExclusivity(subnets []*ec2sdk. // validateSDKSubnetsLocaleExclusivity validates all subnets belong to same locale, and returns the same locale. // subnets passed-in must be non-empty -func (r *defaultSubnetsResolver) validateSubnetsLocaleUniformity(ctx context.Context, subnets []*ec2sdk.Subnet) (subnetLocaleType, error) { +func (r *defaultSubnetsResolver) validateSubnetsLocaleUniformity(ctx context.Context, subnets []ec2types.Subnet) (subnetLocaleType, error) { subnetLocales := sets.NewString() for _, subnet := range subnets { subnetLocale, err := r.buildSDKSubnetLocaleType(ctx, subnet) @@ -366,7 +367,7 @@ func (r *defaultSubnetsResolver) validateSubnetsLocaleUniformity(ctx context.Con } // validateSubnetsMinimalCount validates subnets meets minimal count requirement. -func (r *defaultSubnetsResolver) validateSubnetsMinimalCount(subnets []*ec2sdk.Subnet, subnetLocale subnetLocaleType, resolveOpts SubnetsResolveOptions) error { +func (r *defaultSubnetsResolver) validateSubnetsMinimalCount(subnets []ec2types.Subnet, subnetLocale subnetLocaleType, resolveOpts SubnetsResolveOptions) error { minimalCount := r.computeSubnetsMinimalCount(subnetLocale, resolveOpts) if len(subnets) < minimalCount { return errors.Errorf("subnets count less than minimal required count: %v < %v", len(subnets), minimalCount) @@ -384,17 +385,17 @@ func (r *defaultSubnetsResolver) computeSubnetsMinimalCount(subnetLocale subnetL } // buildSDKSubnetLocaleType builds the locale type for subnet. -func (r *defaultSubnetsResolver) buildSDKSubnetLocaleType(ctx context.Context, subnet *ec2sdk.Subnet) (subnetLocaleType, error) { +func (r *defaultSubnetsResolver) buildSDKSubnetLocaleType(ctx context.Context, subnet ec2types.Subnet) (subnetLocaleType, error) { if subnet.OutpostArn != nil && len(*subnet.OutpostArn) != 0 { return subnetLocaleTypeOutpost, nil } - subnetAZID := awssdk.StringValue(subnet.AvailabilityZoneId) + subnetAZID := awssdk.ToString(subnet.AvailabilityZoneId) azInfoByAZID, err := r.azInfoProvider.FetchAZInfos(ctx, []string{subnetAZID}) if err != nil { return "", err } subnetAZInfo := azInfoByAZID[subnetAZID] - subnetZoneType := awssdk.StringValue(subnetAZInfo.ZoneType) + subnetZoneType := awssdk.ToString(subnetAZInfo.ZoneType) switch subnetZoneType { case zoneTypeAvailabilityZone: return subnetLocaleTypeAvailabilityZone, nil @@ -403,15 +404,15 @@ func (r *defaultSubnetsResolver) buildSDKSubnetLocaleType(ctx context.Context, s case zoneTypeWavelengthZone: return subnetLocaleTypeWavelengthZone, nil default: - return "", errors.Errorf("unknown zone type for subnet %v: %v", awssdk.StringValue(subnet.SubnetId), subnetZoneType) + return "", errors.Errorf("unknown zone type for subnet %v: %v", awssdk.ToString(subnet.SubnetId), subnetZoneType) } } // checkSubnetHasClusterTag checks if the subnet is tagged for the current cluster -func (r *defaultSubnetsResolver) checkSubnetHasClusterTag(subnet *ec2sdk.Subnet) bool { +func (r *defaultSubnetsResolver) checkSubnetHasClusterTag(subnet ec2types.Subnet) bool { clusterResourceTagKey := fmt.Sprintf("kubernetes.io/cluster/%s", r.clusterName) for _, tag := range subnet.Tags { - if clusterResourceTagKey == awssdk.StringValue(tag.Key) { + if clusterResourceTagKey == awssdk.ToString(tag.Key) { return true } } @@ -422,7 +423,7 @@ func (r *defaultSubnetsResolver) checkSubnetHasClusterTag(subnet *ec2sdk.Subnet) // or it doesn't contain the cluster tag at all. If the subnet contains a tag for other clusters, then // this check returns false so that the subnet does not used for the load balancer. // it returns true if the subnetsClusterTagCheck is disabled -func (r *defaultSubnetsResolver) checkSubnetIsNotTaggedForOtherClusters(subnet *ec2sdk.Subnet, subnetsClusterTagCheck bool) bool { +func (r *defaultSubnetsResolver) checkSubnetIsNotTaggedForOtherClusters(subnet ec2types.Subnet, subnetsClusterTagCheck bool) bool { if !subnetsClusterTagCheck { return true } @@ -430,7 +431,7 @@ func (r *defaultSubnetsResolver) checkSubnetIsNotTaggedForOtherClusters(subnet * clusterResourceTagKey := fmt.Sprintf("kubernetes.io/cluster/%s", r.clusterName) hasClusterResourceTagPrefix := false for _, tag := range subnet.Tags { - tagKey := awssdk.StringValue(tag.Key) + tagKey := awssdk.ToString(tag.Key) if tagKey == clusterResourceTagKey { return true } @@ -447,33 +448,33 @@ func (r *defaultSubnetsResolver) checkSubnetIsNotTaggedForOtherClusters(subnet * } // mapSDKSubnetsByAZ builds the subnets slice by AZ mapping. -func mapSDKSubnetsByAZ(subnets []*ec2sdk.Subnet) map[string][]*ec2sdk.Subnet { - subnetsByAZ := make(map[string][]*ec2sdk.Subnet) +func mapSDKSubnetsByAZ(subnets []ec2types.Subnet) map[string][]ec2types.Subnet { + subnetsByAZ := make(map[string][]ec2types.Subnet) for _, subnet := range subnets { - subnetAZ := awssdk.StringValue(subnet.AvailabilityZone) + subnetAZ := awssdk.ToString(subnet.AvailabilityZone) subnetsByAZ[subnetAZ] = append(subnetsByAZ[subnetAZ], subnet) } return subnetsByAZ } // sortSubnetsByID sorts given subnets slice by subnetID. -func sortSubnetsByID(subnets []*ec2sdk.Subnet) { +func sortSubnetsByID(subnets []ec2types.Subnet) { sort.Slice(subnets, func(i, j int) bool { - return awssdk.StringValue(subnets[i].SubnetId) < awssdk.StringValue(subnets[j].SubnetId) + return awssdk.ToString(subnets[i].SubnetId) < awssdk.ToString(subnets[j].SubnetId) }) } -func (r *defaultSubnetsResolver) filterSubnetsByAvailableIPAddress(subnets []*ec2sdk.Subnet, availableIPAddressCount int64) ([]*ec2sdk.Subnet, int) { - filteredSubnets := make([]*ec2sdk.Subnet, 0, len(subnets)) +func (r *defaultSubnetsResolver) filterSubnetsByAvailableIPAddress(subnets []ec2types.Subnet, availableIPAddressCount int32) ([]ec2types.Subnet, int) { + filteredSubnets := make([]ec2types.Subnet, 0, len(subnets)) insufficientIPs := 0 for _, subnet := range subnets { - if awssdk.Int64Value(subnet.AvailableIpAddressCount) >= availableIPAddressCount { + if awssdk.ToInt32(subnet.AvailableIpAddressCount) >= availableIPAddressCount { filteredSubnets = append(filteredSubnets, subnet) } else { insufficientIPs += 1 r.logger.Info("ELB requires at least 8 free IP addresses in each subnet", - "not enough IP addresses found in ", awssdk.StringValue(subnet.SubnetId)) + "not enough IP addresses found in ", awssdk.ToString(subnet.SubnetId)) } } return filteredSubnets, insufficientIPs diff --git a/pkg/networking/subnet_resolver_mocks.go b/pkg/networking/subnet_resolver_mocks.go index 8fa30efe45..83f7fb1d4f 100644 --- a/pkg/networking/subnet_resolver_mocks.go +++ b/pkg/networking/subnet_resolver_mocks.go @@ -8,7 +8,7 @@ import ( context "context" reflect "reflect" - ec2 "github.com/aws/aws-sdk-go/service/ec2" + types "github.com/aws/aws-sdk-go-v2/service/ec2/types" gomock "github.com/golang/mock/gomock" v1beta1 "sigs.k8s.io/aws-load-balancer-controller/apis/elbv2/v1beta1" ) @@ -37,14 +37,14 @@ func (m *MockSubnetsResolver) EXPECT() *MockSubnetsResolverMockRecorder { } // ResolveViaDiscovery mocks base method. -func (m *MockSubnetsResolver) ResolveViaDiscovery(arg0 context.Context, arg1 ...SubnetsResolveOption) ([]*ec2.Subnet, error) { +func (m *MockSubnetsResolver) ResolveViaDiscovery(arg0 context.Context, arg1 ...SubnetsResolveOption) ([]types.Subnet, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0} for _, a := range arg1 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResolveViaDiscovery", varargs...) - ret0, _ := ret[0].([]*ec2.Subnet) + ret0, _ := ret[0].([]types.Subnet) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -57,14 +57,14 @@ func (mr *MockSubnetsResolverMockRecorder) ResolveViaDiscovery(arg0 interface{}, } // ResolveViaNameOrIDSlice mocks base method. -func (m *MockSubnetsResolver) ResolveViaNameOrIDSlice(arg0 context.Context, arg1 []string, arg2 ...SubnetsResolveOption) ([]*ec2.Subnet, error) { +func (m *MockSubnetsResolver) ResolveViaNameOrIDSlice(arg0 context.Context, arg1 []string, arg2 ...SubnetsResolveOption) ([]types.Subnet, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResolveViaNameOrIDSlice", varargs...) - ret0, _ := ret[0].([]*ec2.Subnet) + ret0, _ := ret[0].([]types.Subnet) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -77,14 +77,14 @@ func (mr *MockSubnetsResolverMockRecorder) ResolveViaNameOrIDSlice(arg0, arg1 in } // ResolveViaSelector mocks base method. -func (m *MockSubnetsResolver) ResolveViaSelector(arg0 context.Context, arg1 *v1beta1.SubnetSelector, arg2 ...SubnetsResolveOption) ([]*ec2.Subnet, error) { +func (m *MockSubnetsResolver) ResolveViaSelector(arg0 context.Context, arg1 *v1beta1.SubnetSelector, arg2 ...SubnetsResolveOption) ([]types.Subnet, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResolveViaSelector", varargs...) - ret0, _ := ret[0].([]*ec2.Subnet) + ret0, _ := ret[0].([]types.Subnet) ret1, _ := ret[1].(error) return ret0, ret1 } diff --git a/pkg/networking/subnet_resolver_test.go b/pkg/networking/subnet_resolver_test.go index 8859e01239..38bf50e7e1 100644 --- a/pkg/networking/subnet_resolver_test.go +++ b/pkg/networking/subnet_resolver_test.go @@ -3,10 +3,11 @@ package networking import ( "context" "errors" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/google/go-cmp/cmp" @@ -20,12 +21,12 @@ import ( func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { type describeSubnetsAsListCall struct { input *ec2sdk.DescribeSubnetsInput - output []*ec2sdk.Subnet + output []ec2types.Subnet err error } type fetchAZInfosCall struct { availabilityZoneIDs []string - azInfoByAZID map[string]ec2sdk.AvailabilityZone + azInfoByAZID map[string]ec2types.AvailabilityZone err error } type fields struct { @@ -38,14 +39,14 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { opts []SubnetsResolveOption } const ( - minimalAvailableIPAddressCount = int64(8) + minimalAvailableIPAddressCount = int32(8) defaultSubnetsClusterTagCheck = true ) tests := []struct { name string fields fields args args - want []*ec2sdk.Subnet + want []ec2types.Subnet wantErr error }{ { @@ -56,18 +57,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -86,7 +87,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -95,7 +96,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -110,7 +111,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternetFacing), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -133,18 +134,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -163,7 +164,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -172,7 +173,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -187,7 +188,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -210,14 +211,14 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, @@ -241,14 +242,14 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, @@ -272,18 +273,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -296,7 +297,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -311,7 +312,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -328,18 +329,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -352,7 +353,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -377,18 +378,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-lax-1a"), @@ -401,7 +402,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-lax1-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-lax1-az1": { ZoneId: awssdk.String("usw2-lax1-az1"), ZoneType: awssdk.String("local-zone"), @@ -416,7 +417,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-lax-1a"), @@ -433,18 +434,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -462,7 +463,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -480,18 +481,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-3"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -522,7 +523,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -531,7 +532,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -546,7 +547,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -569,18 +570,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -600,7 +601,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -625,14 +626,14 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/internal-elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, @@ -656,18 +657,18 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2b"), @@ -679,7 +680,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -692,7 +693,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -707,13 +708,13 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternetFacing), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-2"), AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -730,24 +731,24 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -759,7 +760,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -771,7 +772,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/no-cluster"), Value: awssdk.String("owned"), @@ -783,7 +784,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -802,7 +803,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -811,7 +812,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az3"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az3": { ZoneId: awssdk.String("usw2-az3"), ZoneType: awssdk.String("availability-zone"), @@ -827,13 +828,13 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsClusterTagCheck(defaultSubnetsClusterTagCheck), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-2"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -856,24 +857,24 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-3"), AvailabilityZone: awssdk.String("us-west-2c"), AvailabilityZoneId: awssdk.String("usw2-az3"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -885,7 +886,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -897,7 +898,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2c"), AvailabilityZoneId: awssdk.String("usw2-az3"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -910,7 +911,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -919,7 +920,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az3"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az3": { ZoneId: awssdk.String("usw2-az3"), ZoneType: awssdk.String("availability-zone"), @@ -935,13 +936,13 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsClusterTagCheck(false), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -953,7 +954,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { AvailabilityZone: awssdk.String("us-west-2c"), AvailabilityZoneId: awssdk.String("usw2-az3"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/kube-cluster"), Value: awssdk.String("owned"), @@ -970,24 +971,24 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -1004,7 +1005,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1019,13 +1020,13 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternetFacing), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - Tags: []*ec2sdk.Tag{ + Tags: []ec2types.Tag{ { Key: awssdk.String("kubernetes.io/cluster/some-other-cluster"), Value: awssdk.String("owned"), @@ -1046,52 +1047,52 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, { Name: awssdk.String("tag:kubernetes.io/role/elb"), - Values: awssdk.StringSlice([]string{"", "1"}), + Values: []string{"", "1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(0), + AvailableIpAddressCount: awssdk.Int32(0), }, { SubnetId: awssdk.String("subnet-3"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(8), + AvailableIpAddressCount: awssdk.Int32(8), }, { SubnetId: awssdk.String("subnet-4"), AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(25), + AvailableIpAddressCount: awssdk.Int32(25), }, { SubnetId: awssdk.String("subnet-2"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(2), + AvailableIpAddressCount: awssdk.Int32(2), }, { SubnetId: awssdk.String("subnet-5"), AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(10), + AvailableIpAddressCount: awssdk.Int32(10), }, }, }, @@ -1099,7 +1100,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1108,7 +1109,7 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -1124,20 +1125,20 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { WithSubnetsResolveAvailableIPAddressCount(minimalAvailableIPAddressCount), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-3"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(8), + AvailableIpAddressCount: awssdk.Int32(8), }, { SubnetId: awssdk.String("subnet-4"), AvailabilityZone: awssdk.String("us-west-2b"), AvailabilityZoneId: awssdk.String("usw2-az2"), VpcId: awssdk.String("vpc-1"), - AvailableIpAddressCount: awssdk.Int64(25), + AvailableIpAddressCount: awssdk.Int32(25), }, }, }, @@ -1171,9 +1172,13 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { assert.EqualError(t, err, tt.wantErr.Error()) } else { assert.NoError(t, err) - opts := cmpopts.SortSlices(func(lhs *ec2sdk.Subnet, rhs *ec2sdk.Subnet) bool { - return awssdk.StringValue(lhs.SubnetId) < awssdk.StringValue(rhs.SubnetId) - }) + opts := cmp.Options{ + cmpopts.SortSlices(func(lhs *ec2types.Subnet, rhs *ec2types.Subnet) bool { + return awssdk.ToString(lhs.SubnetId) < awssdk.ToString(rhs.SubnetId) + }), + cmpopts.IgnoreUnexported(ec2types.Subnet{}), + cmpopts.IgnoreUnexported(ec2types.Tag{}), + } assert.True(t, cmp.Equal(tt.want, got, opts), "diff", cmp.Diff(tt.want, got, opts)) } }) @@ -1183,12 +1188,12 @@ func Test_defaultSubnetsResolver_ResolveViaDiscovery(t *testing.T) { func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { type describeSubnetsAsListCall struct { input *ec2sdk.DescribeSubnetsInput - output []*ec2sdk.Subnet + output []ec2types.Subnet err error } type fetchAZInfosCall struct { availabilityZoneIDs []string - azInfoByAZID map[string]ec2sdk.AvailabilityZone + azInfoByAZID map[string]ec2types.AvailabilityZone err error } type fields struct { @@ -1205,7 +1210,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { name string fields fields args args - want []*ec2sdk.Subnet + want []ec2types.Subnet wantErr error }{ { @@ -1216,9 +1221,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1", "subnet-2"}), + SubnetIds: []string{"subnet-1", "subnet-2"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1237,7 +1242,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1246,7 +1251,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -1262,7 +1267,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1285,18 +1290,18 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{"my-name-1", "my-name-2"}), + Values: []string{"my-name-1", "my-name-2"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1315,7 +1320,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1324,7 +1329,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -1340,7 +1345,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1363,9 +1368,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1"}), + SubnetIds: []string{"subnet-1"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1376,18 +1381,18 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { }, { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{"my-name-2"}), + Values: []string{"my-name-2"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-2"), AvailabilityZone: awssdk.String("us-west-2b"), @@ -1400,7 +1405,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1409,7 +1414,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { }, { availabilityZoneIDs: []string{"usw2-az2"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az2": { ZoneId: awssdk.String("usw2-az2"), ZoneType: awssdk.String("availability-zone"), @@ -1425,7 +1430,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1448,18 +1453,18 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:Name"), - Values: awssdk.StringSlice([]string{"my-name-1", "my-name-2", "my-name-3"}), + Values: []string{"my-name-1", "my-name-2", "my-name-3"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{"vpc-1"}), + Values: []string{"vpc-1"}, }, }, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1507,9 +1512,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1", "subnet-2", "subnet-3"}), + SubnetIds: []string{"subnet-1", "subnet-2", "subnet-3"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1546,9 +1551,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1", "subnet-2"}), + SubnetIds: []string{"subnet-1", "subnet-2"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1568,7 +1573,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1594,9 +1599,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1"}), + SubnetIds: []string{"subnet-1"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1609,7 +1614,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1635,9 +1640,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1"}), + SubnetIds: []string{"subnet-1"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-lax-1a"), @@ -1650,7 +1655,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-lax1-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-lax1-az1": { ZoneId: awssdk.String("usw2-lax1-az1"), ZoneType: awssdk.String("local-zone"), @@ -1666,7 +1671,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-lax-1a"), @@ -1683,9 +1688,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1"}), + SubnetIds: []string{"subnet-1"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1704,7 +1709,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1722,9 +1727,9 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { describeSubnetsAsListCalls: []describeSubnetsAsListCall{ { input: &ec2sdk.DescribeSubnetsInput{ - SubnetIds: awssdk.StringSlice([]string{"subnet-1"}), + SubnetIds: []string{"subnet-1"}, }, - output: []*ec2sdk.Subnet{ + output: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1737,7 +1742,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1753,7 +1758,7 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { WithSubnetsResolveLBScheme(elbv2model.LoadBalancerSchemeInternal), }, }, - want: []*ec2sdk.Subnet{ + want: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), @@ -1790,9 +1795,13 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { assert.EqualError(t, err, tt.wantErr.Error()) } else { assert.NoError(t, err) - opts := cmpopts.SortSlices(func(lhs *ec2sdk.Subnet, rhs *ec2sdk.Subnet) bool { - return awssdk.StringValue(lhs.SubnetId) < awssdk.StringValue(rhs.SubnetId) - }) + opts := cmp.Options{ + cmpopts.SortSlices(func(lhs *ec2types.Subnet, rhs *ec2types.Subnet) bool { + return awssdk.ToString(lhs.SubnetId) < awssdk.ToString(rhs.SubnetId) + }), + cmpopts.IgnoreUnexported(ec2types.Subnet{}), + cmpopts.IgnoreUnexported(ec2types.Tag{}), + } assert.True(t, cmp.Equal(tt.want, got, opts), "diff", cmp.Diff(tt.want, got, opts)) } }) @@ -1802,14 +1811,14 @@ func Test_defaultSubnetsResolver_ResolveViaNameOrIDSlice(t *testing.T) { func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { type fetchAZInfosCall struct { availabilityZoneIDs []string - azInfoByAZID map[string]ec2sdk.AvailabilityZone + azInfoByAZID map[string]ec2types.AvailabilityZone err error } type fields struct { fetchAZInfosCalls []fetchAZInfosCall } type args struct { - subnet *ec2sdk.Subnet + subnet ec2types.Subnet } tests := []struct { name string @@ -1824,7 +1833,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("availability-zone"), @@ -1834,7 +1843,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { }, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), @@ -1849,7 +1858,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-lax1-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-lax1-az1": { ZoneId: awssdk.String("usw2-lax1-az1"), ZoneType: awssdk.String("local-zone"), @@ -1859,7 +1868,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { }, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-lax-1a"), AvailabilityZoneId: awssdk.String("usw2-lax1-az1"), @@ -1874,7 +1883,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-wl1-las-wlz1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-wl1-las-wlz1": { ZoneId: awssdk.String("usw2-lax1-az1"), ZoneType: awssdk.String("wavelength-zone"), @@ -1884,7 +1893,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { }, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2-wl1-las-wlz-1"), AvailabilityZoneId: awssdk.String("usw2-wl1-las-wlz1"), @@ -1899,7 +1908,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { fetchAZInfosCalls: nil, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), @@ -1920,7 +1929,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { }, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("invalid-zone"), AvailabilityZoneId: awssdk.String("invalid-zone-id"), @@ -1935,7 +1944,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { fetchAZInfosCalls: []fetchAZInfosCall{ { availabilityZoneIDs: []string{"usw2-az1"}, - azInfoByAZID: map[string]ec2sdk.AvailabilityZone{ + azInfoByAZID: map[string]ec2types.AvailabilityZone{ "usw2-az1": { ZoneId: awssdk.String("usw2-az1"), ZoneType: awssdk.String("unknown"), @@ -1945,7 +1954,7 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { }, }, args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ SubnetId: awssdk.String("subnet-1"), AvailabilityZone: awssdk.String("us-west-2a"), AvailabilityZoneId: awssdk.String("usw2-az1"), @@ -1981,17 +1990,17 @@ func Test_defaultSubnetsResolver_buildSDKSubnetLocaleType(t *testing.T) { func Test_sortSubnetsByID(t *testing.T) { type args struct { - subnets []*ec2sdk.Subnet + subnets []ec2types.Subnet } tests := []struct { name string args args - wantSubnets []*ec2sdk.Subnet + wantSubnets []ec2types.Subnet }{ { name: "subnets already sorted", args: args{ - subnets: []*ec2sdk.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-a"), }, @@ -2002,7 +2011,7 @@ func Test_sortSubnetsByID(t *testing.T) { }, }, }, - wantSubnets: []*ec2sdk.Subnet{ + wantSubnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-a"), }, @@ -2016,7 +2025,7 @@ func Test_sortSubnetsByID(t *testing.T) { { name: "subnets not sorted", args: args{ - subnets: []*ec2sdk.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-c"), }, @@ -2028,7 +2037,7 @@ func Test_sortSubnetsByID(t *testing.T) { }, }, }, - wantSubnets: []*ec2sdk.Subnet{ + wantSubnets: []ec2types.Subnet{ { SubnetId: awssdk.String("subnet-a"), }, diff --git a/pkg/networking/utils.go b/pkg/networking/utils.go index 4d9be557db..c3a7aac9cd 100644 --- a/pkg/networking/utils.go +++ b/pkg/networking/utils.go @@ -1,8 +1,8 @@ package networking import ( - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "net/netip" ) @@ -44,11 +44,11 @@ func FilterIPsWithinCIDRs(ips []netip.Addr, cidrs []netip.Prefix) []netip.Addr { } // GetSubnetAssociatedIPv4CIDRs returns the IPv4 CIDRs associated with EC2 subnet -func GetSubnetAssociatedIPv4CIDRs(subnet *ec2sdk.Subnet) ([]netip.Prefix, error) { +func GetSubnetAssociatedIPv4CIDRs(subnet ec2types.Subnet) ([]netip.Prefix, error) { if subnet.CidrBlock == nil { return nil, nil } - cidrBlock := awssdk.StringValue(subnet.CidrBlock) + cidrBlock := awssdk.ToString(subnet.CidrBlock) ipv4CIDR, err := netip.ParsePrefix(cidrBlock) if err != nil { return nil, err @@ -57,13 +57,13 @@ func GetSubnetAssociatedIPv4CIDRs(subnet *ec2sdk.Subnet) ([]netip.Prefix, error) } // GetSubnetAssociatedIPv6CIDRs returns the IPv6 CIDRs associated with EC2 subnet -func GetSubnetAssociatedIPv6CIDRs(subnet *ec2sdk.Subnet) ([]netip.Prefix, error) { +func GetSubnetAssociatedIPv6CIDRs(subnet ec2types.Subnet) ([]netip.Prefix, error) { var ipv6CIDRs []netip.Prefix for _, cidrAssociation := range subnet.Ipv6CidrBlockAssociationSet { - if awssdk.StringValue(cidrAssociation.Ipv6CidrBlockState.State) != ec2sdk.SubnetCidrBlockStateCodeAssociated { + if cidrAssociation.Ipv6CidrBlockState.State != ec2types.SubnetCidrBlockStateCodeAssociated { continue } - cidrBlock := awssdk.StringValue(cidrAssociation.Ipv6CidrBlock) + cidrBlock := awssdk.ToString(cidrAssociation.Ipv6CidrBlock) ipv6CIDR, err := netip.ParsePrefix(cidrBlock) if err != nil { return nil, err diff --git a/pkg/networking/utils_test.go b/pkg/networking/utils_test.go index 53416df6ce..c3f43f10f5 100644 --- a/pkg/networking/utils_test.go +++ b/pkg/networking/utils_test.go @@ -1,8 +1,8 @@ package networking import ( - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/pkg/errors" "github.com/stretchr/testify/assert" @@ -230,7 +230,7 @@ func TestFilterIPsWithinCIDRs(t *testing.T) { func TestGetSubnetAssociatedIPv4CIDRs(t *testing.T) { type args struct { - subnet *ec2sdk.Subnet + subnet ec2types.Subnet } tests := []struct { name string @@ -241,7 +241,7 @@ func TestGetSubnetAssociatedIPv4CIDRs(t *testing.T) { { name: "one IPv4 CIDR", args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ CidrBlock: awssdk.String("192.168.1.0/24"), }, }, @@ -264,7 +264,7 @@ func TestGetSubnetAssociatedIPv4CIDRs(t *testing.T) { func TestGetSubnetAssociatedIPv6CIDRs(t *testing.T) { type args struct { - subnet *ec2sdk.Subnet + subnet ec2types.Subnet } tests := []struct { name string @@ -275,13 +275,13 @@ func TestGetSubnetAssociatedIPv6CIDRs(t *testing.T) { { name: "one IPv6 CIDR", args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ CidrBlock: awssdk.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2sdk.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: awssdk.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2sdk.SubnetCidrBlockState{ - State: awssdk.String(ec2sdk.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -294,19 +294,19 @@ func TestGetSubnetAssociatedIPv6CIDRs(t *testing.T) { { name: "multiple IPv6 CIDR", args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ CidrBlock: awssdk.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2sdk.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: awssdk.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2sdk.SubnetCidrBlockState{ - State: awssdk.String(ec2sdk.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, { Ipv6CidrBlock: awssdk.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2sdk.SubnetCidrBlockState{ - State: awssdk.String(ec2sdk.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -320,7 +320,7 @@ func TestGetSubnetAssociatedIPv6CIDRs(t *testing.T) { { name: "zero IPv6 CIDR", args: args{ - subnet: &ec2sdk.Subnet{ + subnet: ec2types.Subnet{ CidrBlock: awssdk.String("192.168.1.0/24"), }, }, diff --git a/pkg/networking/vpc_info_provider.go b/pkg/networking/vpc_info_provider.go index 456c5549db..a2b10d9b40 100644 --- a/pkg/networking/vpc_info_provider.go +++ b/pkg/networking/vpc_info_provider.go @@ -2,11 +2,12 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "sync" "time" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/cache" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -14,16 +15,16 @@ import ( const defaultVPCInfoCacheTTL = 10 * time.Minute -type VPCInfo ec2sdk.Vpc +type VPCInfo ec2types.Vpc // AssociatedIPv4CIDRs computes associated IPv4CIDRs for VPC. func (vpc *VPCInfo) AssociatedIPv4CIDRs() []string { var ipv4CIDRs []string for _, cidr := range vpc.CidrBlockAssociationSet { - if awssdk.StringValue(cidr.CidrBlockState.State) != ec2sdk.VpcCidrBlockStateCodeAssociated { + if cidr.CidrBlockState.State != ec2types.VpcCidrBlockStateCodeAssociated { continue } - ipv4CIDRs = append(ipv4CIDRs, awssdk.StringValue(cidr.CidrBlock)) + ipv4CIDRs = append(ipv4CIDRs, awssdk.ToString(cidr.CidrBlock)) } return ipv4CIDRs } @@ -32,10 +33,10 @@ func (vpc *VPCInfo) AssociatedIPv4CIDRs() []string { func (vpc *VPCInfo) AssociatedIPv6CIDRs() []string { var ipv6CIDRs []string for _, cidr := range vpc.Ipv6CidrBlockAssociationSet { - if awssdk.StringValue(cidr.Ipv6CidrBlockState.State) != ec2sdk.VpcCidrBlockStateCodeAssociated { + if cidr.Ipv6CidrBlockState.State != ec2types.VpcCidrBlockStateCodeAssociated { continue } - ipv6CIDRs = append(ipv6CIDRs, awssdk.StringValue(cidr.Ipv6CidrBlock)) + ipv6CIDRs = append(ipv6CIDRs, awssdk.ToString(cidr.Ipv6CidrBlock)) } return ipv6CIDRs } @@ -132,12 +133,12 @@ func (p *defaultVPCInfoProvider) saveVPCInfoToCache(vpcID string, vpcInfo VPCInf // fetchVPCInfoFromAWS will fetch VPC info from the AWS API. func (p *defaultVPCInfoProvider) fetchVPCInfoFromAWS(ctx context.Context, vpcID string) (VPCInfo, error) { req := &ec2sdk.DescribeVpcsInput{ - VpcIds: []*string{awssdk.String(vpcID)}, + VpcIds: []string{vpcID}, } resp, err := p.ec2Client.DescribeVpcsWithContext(ctx, req) if err != nil { return VPCInfo{}, err } - return VPCInfo(*resp.Vpcs[0]), nil + return VPCInfo(resp.Vpcs[0]), nil } diff --git a/pkg/networking/vpc_info_provider_test.go b/pkg/networking/vpc_info_provider_test.go index f8b3f9e7f2..170ca1916b 100644 --- a/pkg/networking/vpc_info_provider_test.go +++ b/pkg/networking/vpc_info_provider_test.go @@ -2,10 +2,11 @@ package networking import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -40,17 +41,17 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { describeVpcsCalls: []describeVpcsCall{ { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -65,11 +66,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a348", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -79,11 +80,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a348", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -97,17 +98,17 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { describeVpcsCalls: []describeVpcsCall{ { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -117,23 +118,23 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { }, { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -149,11 +150,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { opts: []FetchVPCInfoOption{FetchVPCInfoWithoutCache()}, want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -164,17 +165,17 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { opts: []FetchVPCInfoOption{FetchVPCInfoWithoutCache()}, want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -188,17 +189,17 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { describeVpcsCalls: []describeVpcsCall{ { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -208,17 +209,17 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { }, { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a842"}), + VpcIds: []string{"vpc-2f09a842"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a842"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -233,11 +234,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a348", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -247,11 +248,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a842", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a842"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -261,11 +262,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a348", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -275,11 +276,11 @@ func Test_defaultVPCInfoProvider_FetchVPCInfo(t *testing.T) { vpcID: "vpc-2f09a842", want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a842"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -338,17 +339,17 @@ func Test_defaultVPCInfoProvider_fetchVPCInfoFromAWS(t *testing.T) { describeVpcsCalls: []describeVpcsCall{ { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, resp: &ec2sdk.DescribeVpcsOutput{ - Vpcs: []*ec2sdk.Vpc{ + Vpcs: []ec2types.Vpc{ { VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -363,11 +364,11 @@ func Test_defaultVPCInfoProvider_fetchVPCInfoFromAWS(t *testing.T) { }, want: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -379,7 +380,7 @@ func Test_defaultVPCInfoProvider_fetchVPCInfoFromAWS(t *testing.T) { describeVpcsCalls: []describeVpcsCall{ { req: &ec2sdk.DescribeVpcsInput{ - VpcIds: awssdk.StringSlice([]string{"vpc-2f09a348"}), + VpcIds: []string{"vpc-2f09a348"}, }, err: errors.New("some error happened"), }, @@ -426,11 +427,11 @@ func TestVPCInfo_AssociatedIPv4CIDRs(t *testing.T) { name: "single associated CIDR", vpc: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -441,23 +442,23 @@ func TestVPCInfo_AssociatedIPv4CIDRs(t *testing.T) { name: "multiple CIDRs", vpc: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - CidrBlockAssociationSet: []*ec2sdk.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: awssdk.String("192.168.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, { CidrBlock: awssdk.String("10.100.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeDisassociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeDisassociated, }, }, { CidrBlock: awssdk.String("172.16.0.0/16"), - CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -483,11 +484,11 @@ func TestVPCInfo_AssociatedIPv6CIDRs(t *testing.T) { name: "single associated CIDR", vpc: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - Ipv6CidrBlockAssociationSet: []*ec2sdk.VpcIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.VpcIpv6CidrBlockAssociation{ { Ipv6CidrBlock: awssdk.String("2600:1f14:f8c:2700::/56"), - Ipv6CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, @@ -498,23 +499,23 @@ func TestVPCInfo_AssociatedIPv6CIDRs(t *testing.T) { name: "multiple CIDRs", vpc: VPCInfo{ VpcId: awssdk.String("vpc-2f09a348"), - Ipv6CidrBlockAssociationSet: []*ec2sdk.VpcIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.VpcIpv6CidrBlockAssociation{ { Ipv6CidrBlock: awssdk.String("2600:1f14:f8c:2700::/56"), - Ipv6CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, { Ipv6CidrBlock: awssdk.String("2700:1f14:f8c:2700::/56"), - Ipv6CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeDisassociated), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeDisassociated, }, }, { Ipv6CidrBlock: awssdk.String("2800:1f14:f8c:2700::/56"), - Ipv6CidrBlockState: &ec2sdk.VpcCidrBlockState{ - State: awssdk.String(ec2sdk.VpcCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: ec2types.VpcCidrBlockStateCodeAssociated, }, }, }, diff --git a/pkg/service/model_build_listener.go b/pkg/service/model_build_listener.go index d320fe5eaf..41f33404f2 100644 --- a/pkg/service/model_build_listener.go +++ b/pkg/service/model_build_listener.go @@ -5,7 +5,7 @@ import ( "fmt" "strconv" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" "k8s.io/apimachinery/pkg/util/sets" @@ -75,7 +75,7 @@ func (t *defaultModelBuildTask) buildListenerSpec(ctx context.Context, port core defaultActions := t.buildListenerDefaultActions(ctx, targetGroup) return elbv2model.ListenerSpec{ LoadBalancerARN: t.loadBalancer.LoadBalancerARN(), - Port: int64(port.Port), + Port: port.Port, Protocol: listenerProtocol, Certificates: certificates, SSLPolicy: sslPolicy, diff --git a/pkg/service/model_build_load_balancer.go b/pkg/service/model_build_load_balancer.go index 1a645205da..6657a41889 100644 --- a/pkg/service/model_build_load_balancer.go +++ b/pkg/service/model_build_load_balancer.go @@ -10,8 +10,8 @@ import ( "sort" "strconv" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/types" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" @@ -35,7 +35,7 @@ const ( partialAvailabilityZoneAffinity = "partial_availability_zone_affinity" anyAvailabilityZone = "any_availability_zone" resourceIDLoadBalancer = "LoadBalancer" - minimalAvailableIPAddressCount = int64(8) + minimalAvailableIPAddressCount = int32(8) ) func (t *defaultModelBuildTask) buildLoadBalancer(ctx context.Context, scheme elbv2model.LoadBalancerScheme) error { @@ -85,8 +85,8 @@ func (t *defaultModelBuildTask) buildLoadBalancerSpec(ctx context.Context, schem spec := elbv2model.LoadBalancerSpec{ Name: name, Type: elbv2model.LoadBalancerTypeNetwork, - Scheme: &scheme, - IPAddressType: &ipAddressType, + Scheme: scheme, + IPAddressType: ipAddressType, SecurityGroups: securityGroups, SubnetMappings: subnetMappings, LoadBalancerAttributes: lbAttributes, @@ -217,7 +217,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerScheme(ctx context.Context) (el return elbv2model.LoadBalancerSchemeInternal, err } if existingLB != nil { - switch awssdk.StringValue(existingLB.LoadBalancer.Scheme) { + switch string(existingLB.LoadBalancer.Scheme) { case string(elbv2model.LoadBalancerSchemeInternal): return elbv2model.LoadBalancerSchemeInternal, nil case string(elbv2model.LoadBalancerSchemeInternetFacing): @@ -297,7 +297,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerTags(ctx context.Context) (map[ return t.buildAdditionalResourceTags(ctx) } -func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Context, ipAddressType elbv2model.IPAddressType, scheme elbv2model.LoadBalancerScheme, ec2Subnets []*ec2sdk.Subnet) ([]elbv2model.SubnetMapping, error) { +func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Context, ipAddressType elbv2model.IPAddressType, scheme elbv2model.LoadBalancerScheme, ec2Subnets []ec2types.Subnet) ([]elbv2model.SubnetMapping, error) { var eipAllocation []string eipConfigured := t.annotationParser.ParseStringSliceAnnotation(annotations.SvcLBSuffixEIPAllocations, &eipAllocation, t.service.Annotations) if eipConfigured { @@ -358,7 +358,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Contex subnetMappings := make([]elbv2model.SubnetMapping, 0, len(ec2Subnets)) for idx, subnet := range ec2Subnets { mapping := elbv2model.SubnetMapping{ - SubnetID: awssdk.StringValue(subnet.SubnetId), + SubnetID: awssdk.ToString(subnet.SubnetId), } if eipConfigured { mapping.AllocationID = awssdk.String(eipAllocation[idx]) @@ -370,7 +370,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Contex } ipv4AddressesWithinSubnet := networking.FilterIPsWithinCIDRs(ipv4Addresses, subnetIPv4CIDRs) if len(ipv4AddressesWithinSubnet) != 1 { - return nil, errors.Errorf("expect one private IPv4 address configured for subnet: %v", awssdk.StringValue(subnet.SubnetId)) + return nil, errors.Errorf("expect one private IPv4 address configured for subnet: %v", awssdk.ToString(subnet.SubnetId)) } mapping.PrivateIPv4Address = awssdk.String(ipv4AddressesWithinSubnet[0].String()) } @@ -381,7 +381,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Contex } ipv6AddressesWithinSubnet := networking.FilterIPsWithinCIDRs(ipv6Addresses, subnetIPv6CIDRs) if len(ipv6AddressesWithinSubnet) != 1 { - return nil, errors.Errorf("expect one IPv6 address configured for subnet: %v", awssdk.StringValue(subnet.SubnetId)) + return nil, errors.Errorf("expect one IPv6 address configured for subnet: %v", awssdk.ToString(subnet.SubnetId)) } mapping.IPv6Address = awssdk.String(ipv6AddressesWithinSubnet[0].String()) } @@ -390,7 +390,7 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnetMappings(_ context.Contex return subnetMappings, nil } -func (t *defaultModelBuildTask) buildLoadBalancerSubnets(ctx context.Context, scheme elbv2model.LoadBalancerScheme) ([]*ec2sdk.Subnet, error) { +func (t *defaultModelBuildTask) buildLoadBalancerSubnets(ctx context.Context, scheme elbv2model.LoadBalancerScheme) ([]ec2types.Subnet, error) { var rawSubnetNameOrIDs []string if exists := t.annotationParser.ParseStringSliceAnnotation(annotations.SvcLBSuffixSubnets, &rawSubnetNameOrIDs, t.service.Annotations); exists { return t.subnetsResolver.ResolveViaNameOrIDSlice(ctx, rawSubnetNameOrIDs, @@ -403,11 +403,11 @@ func (t *defaultModelBuildTask) buildLoadBalancerSubnets(ctx context.Context, sc if err != nil { return nil, err } - if existingLB != nil && string(scheme) == awssdk.StringValue(existingLB.LoadBalancer.Scheme) { + if existingLB != nil && string(scheme) == string(existingLB.LoadBalancer.Scheme) { availabilityZones := existingLB.LoadBalancer.AvailabilityZones subnetIDs := make([]string, 0, len(availabilityZones)) for _, availabilityZone := range availabilityZones { - subnetID := awssdk.StringValue(availabilityZone.SubnetId) + subnetID := awssdk.ToString(availabilityZone.SubnetId) subnetIDs = append(subnetIDs, subnetID) } return t.subnetsResolver.ResolveViaNameOrIDSlice(ctx, subnetIDs, diff --git a/pkg/service/model_build_load_balancer_test.go b/pkg/service/model_build_load_balancer_test.go index b90a566f3f..65551cce1c 100644 --- a/pkg/service/model_build_load_balancer_test.go +++ b/pkg/service/model_build_load_balancer_test.go @@ -3,15 +3,15 @@ package service import ( "context" "errors" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" "k8s.io/apimachinery/pkg/util/sets" "sigs.k8s.io/aws-load-balancer-controller/pkg/model/core" "sigs.k8s.io/aws-load-balancer-controller/pkg/networking" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" @@ -203,7 +203,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name string ipAddressType elbv2.IPAddressType scheme elbv2.LoadBalancerScheme - subnets []*ec2.Subnet + subnets []ec2types.Subnet want []elbv2.SubnetMapping svc *corev1.Service wantErr error @@ -212,7 +212,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with auto-assigned addresses", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -240,7 +240,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with EIP allocation", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -276,7 +276,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with EIP allocation: on internal load balancer", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -303,7 +303,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with EIP allocation: subnet count mismatch", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -330,7 +330,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -366,7 +366,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address: on internet-facing load balancer", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -393,7 +393,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIpv4Addresses: subnet count mismatch", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -418,7 +418,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address: no matching IP for subnets", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -445,7 +445,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -481,7 +481,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address: invalid ip format", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -508,7 +508,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "ipv4 - with PrivateIPv4Address: invalid ipv4 format", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), @@ -535,17 +535,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -555,11 +555,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -587,17 +587,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses: on a ipv4 load balancer", ipAddressType: elbv2.IPAddressTypeIPV4, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -607,11 +607,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -630,17 +630,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses: subnet count mismatch", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -650,11 +650,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -673,17 +673,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses: no matching IP for subnets", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -693,11 +693,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -716,17 +716,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses: invalid IP format", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -736,11 +736,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -759,17 +759,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with IPv6Addresses: invalid IP format", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -779,11 +779,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -802,17 +802,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with EIPAllocation and IPv6Addresses", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -822,11 +822,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -857,17 +857,17 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { name: "dualstack - with EIPAllocation and IPv6Addresses", ipAddressType: elbv2.IPAddressTypeDualStack, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-1"), AvailabilityZone: aws.String("us-west-2a"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.1.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8500::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -877,11 +877,11 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { AvailabilityZone: aws.String("us-west-2b"), VpcId: aws.String("vpc-1"), CidrBlock: aws.String("192.168.2.0/24"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2600:1f13:837:8504::/64"), - Ipv6CidrBlockState: &ec2.SubnetCidrBlockState{ - State: aws.String(ec2.SubnetCidrBlockStateCodeAssociated), + Ipv6CidrBlockState: &ec2types.SubnetCidrBlockState{ + State: ec2types.SubnetCidrBlockStateCodeAssociated, }, }, }, @@ -929,7 +929,7 @@ func Test_defaultModelBuilderTask_buildSubnetMappings(t *testing.T) { func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { type resolveSubnetResults struct { - subnets []*ec2.Subnet + subnets []ec2types.Subnet err error } type args struct { @@ -951,7 +951,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { listLoadBalancersCalls []listLoadBalancerCall resolveViaDiscoveryCalls []resolveSubnetResults resolveViaNameOrIDSliceCalls []resolveSubnetResults - want []*ec2.Subnet + want []ec2types.Subnet wantErr error }{ { @@ -963,7 +963,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { listLoadBalancersCalls: []listLoadBalancerCall{listLoadBalancerCallForEmptyLB}, resolveViaDiscoveryCalls: []resolveSubnetResults{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-a"), CidrBlock: aws.String("192.168.0.0/19"), @@ -975,7 +975,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, }, }, - want: []*ec2.Subnet{ + want: []ec2types.Subnet{ { SubnetId: aws.String("subnet-a"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1000,7 +1000,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { args: args{stack: core.NewDefaultStack(core.StackID{Namespace: "namespace", Name: "serviceName"})}, resolveViaNameOrIDSliceCalls: []resolveSubnetResults{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-abc"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1012,7 +1012,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, }, }, - want: []*ec2.Subnet{ + want: []ec2types.Subnet{ { SubnetId: aws.String("subnet-abc"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1033,9 +1033,9 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { { sdkLBs: []elbv2deploy.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: aws.String("lb-1"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + AvailabilityZones: []elbv2types.AvailabilityZone{ { SubnetId: aws.String("subnet-c"), }, @@ -1043,7 +1043,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { SubnetId: aws.String("subnet-d"), }, }, - Scheme: aws.String("internal"), + Scheme: elbv2types.LoadBalancerSchemeEnumInternal, }, Tags: map[string]string{ "elbv2.k8s.aws/cluster": "cluster-name", @@ -1055,7 +1055,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, resolveViaNameOrIDSliceCalls: []resolveSubnetResults{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-c"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1067,7 +1067,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, }, }, - want: []*ec2.Subnet{ + want: []ec2types.Subnet{ { SubnetId: aws.String("subnet-c"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1088,9 +1088,9 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { { sdkLBs: []elbv2deploy.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ + LoadBalancer: &elbv2types.LoadBalancer{ LoadBalancerArn: aws.String("lb-1"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + AvailabilityZones: []elbv2types.AvailabilityZone{ { SubnetId: aws.String("subnet-c"), }, @@ -1098,7 +1098,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { SubnetId: aws.String("subnet-d"), }, }, - Scheme: aws.String("internet-facing"), + Scheme: elbv2types.LoadBalancerSchemeEnumInternetFacing, }, Tags: map[string]string{ "elbv2.k8s.aws/cluster": "cluster-name", @@ -1110,7 +1110,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, resolveViaDiscoveryCalls: []resolveSubnetResults{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { SubnetId: aws.String("subnet-a"), CidrBlock: aws.String("192.168.0.0/19"), @@ -1122,7 +1122,7 @@ func Test_defaultModelBuilderTask_buildLoadBalancerSubnets(t *testing.T) { }, }, }, - want: []*ec2.Subnet{ + want: []ec2types.Subnet{ { SubnetId: aws.String("subnet-a"), CidrBlock: aws.String("192.168.0.0/19"), diff --git a/pkg/service/model_build_managed_sg.go b/pkg/service/model_build_managed_sg.go index 498994b2a2..a44a7ae34d 100644 --- a/pkg/service/model_build_managed_sg.go +++ b/pkg/service/model_build_managed_sg.go @@ -8,7 +8,7 @@ import ( "regexp" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/algorithm" "sigs.k8s.io/aws-load-balancer-controller/pkg/annotations" @@ -71,13 +71,13 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(ctx return nil, err } for _, port := range t.service.Spec.Ports { - listenPort := int64(port.Port) + listenPort := int32(port.Port) for _, cidr := range cidrs { if !strings.Contains(cidr, ":") { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: strings.ToLower(string(port.Protocol)), - FromPort: awssdk.Int64(listenPort), - ToPort: awssdk.Int64(listenPort), + FromPort: awssdk.Int32(listenPort), + ToPort: awssdk.Int32(listenPort), IPRanges: []ec2model.IPRange{ { CIDRIP: cidr, @@ -87,8 +87,8 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(ctx } else { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: strings.ToLower(string(port.Protocol)), - FromPort: awssdk.Int64(listenPort), - ToPort: awssdk.Int64(listenPort), + FromPort: awssdk.Int32(listenPort), + ToPort: awssdk.Int32(listenPort), IPv6Range: []ec2model.IPv6Range{ { CIDRIPv6: cidr, @@ -101,8 +101,8 @@ func (t *defaultModelBuildTask) buildManagedSecurityGroupIngressPermissions(ctx for _, prefixID := range prefixListIDs { permissions = append(permissions, ec2model.IPPermission{ IPProtocol: strings.ToLower(string(port.Protocol)), - FromPort: awssdk.Int64(listenPort), - ToPort: awssdk.Int64(listenPort), + FromPort: awssdk.Int32(listenPort), + ToPort: awssdk.Int32(listenPort), PrefixLists: []ec2model.PrefixList{ { ListID: prefixID, diff --git a/pkg/service/model_build_managed_sg_test.go b/pkg/service/model_build_managed_sg_test.go index 0859549572..26188ec5f7 100644 --- a/pkg/service/model_build_managed_sg_test.go +++ b/pkg/service/model_build_managed_sg_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -130,8 +130,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions want: []ec2model.IPPermission{ { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), IPRanges: []ec2model.IPRange{ { CIDRIP: "0.0.0.0/0", @@ -166,8 +166,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions want: []ec2model.IPPermission{ { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), IPRanges: []ec2model.IPRange{ { CIDRIP: "0.0.0.0/0", @@ -176,8 +176,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions }, { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), IPv6Range: []ec2model.IPv6Range{ { CIDRIPv6: "::/0", @@ -213,8 +213,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions want: []ec2model.IPPermission{ { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), PrefixLists: []ec2model.PrefixList{ { ListID: "pl-xxxxx", @@ -250,8 +250,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions want: []ec2model.IPPermission{ { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), PrefixLists: []ec2model.PrefixList{ { ListID: "pl-xxxxx", @@ -260,8 +260,8 @@ func Test_buildCIDRsFromSourceRanges_buildManagedSecurityGroupIngressPermissions }, { IPProtocol: "", - FromPort: aws.Int64(80), - ToPort: aws.Int64(80), + FromPort: aws.Int32(80), + ToPort: aws.Int32(80), PrefixLists: []ec2model.PrefixList{ { ListID: "pl-yyyyyy", diff --git a/pkg/service/model_build_target_group.go b/pkg/service/model_build_target_group.go index 16682eb6ef..f47d631e8e 100644 --- a/pkg/service/model_build_target_group.go +++ b/pkg/service/model_build_target_group.go @@ -10,7 +10,7 @@ import ( "strconv" "strings" - "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -80,9 +80,9 @@ func (t *defaultModelBuildTask) buildTargetGroupSpec(ctx context.Context, tgProt return elbv2model.TargetGroupSpec{ Name: tgName, TargetType: targetType, - Port: targetPort, + Port: awssdk.Int32(targetPort), Protocol: tgProtocol, - IPAddressType: &ipAddressType, + IPAddressType: ipAddressType, HealthCheckConfig: healthCheckConfig, TargetGroupAttributes: tgAttrs, Tags: tags, @@ -127,7 +127,7 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckConfigDefault(ctx con } return &elbv2model.TargetGroupHealthCheckConfig{ Port: &healthCheckPort, - Protocol: &healthCheckProtocol, + Protocol: healthCheckProtocol, Path: healthCheckPathPtr, Matcher: healthCheckMatcherPtr, IntervalSeconds: &intervalSeconds, @@ -166,7 +166,7 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckConfigForInstanceMode } return &elbv2model.TargetGroupHealthCheckConfig{ Port: &healthCheckPort, - Protocol: &healthCheckProtocol, + Protocol: healthCheckProtocol, Path: healthCheckPathPtr, Matcher: healthCheckMatcherPtr, IntervalSeconds: &intervalSeconds, @@ -178,15 +178,15 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckConfigForInstanceMode var invalidTargetGroupNamePattern = regexp.MustCompile("[[:^alnum:]]") -func (t *defaultModelBuildTask) buildTargetGroupName(_ context.Context, svcPort intstr.IntOrString, tgPort int64, +func (t *defaultModelBuildTask) buildTargetGroupName(_ context.Context, svcPort intstr.IntOrString, tgPort int32, targetType elbv2model.TargetType, tgProtocol elbv2model.Protocol, hc *elbv2model.TargetGroupHealthCheckConfig) string { healthCheckProtocol := string(elbv2model.ProtocolTCP) - healthCheckInterval := strconv.FormatInt(t.defaultHealthCheckInterval, 10) - if hc.Protocol != nil { - healthCheckProtocol = string(*hc.Protocol) + healthCheckInterval := strconv.FormatInt(int64(t.defaultHealthCheckInterval), 10) + if &hc.Protocol != nil { + healthCheckProtocol = string(hc.Protocol) } if hc.IntervalSeconds != nil { - healthCheckInterval = strconv.FormatInt(*hc.IntervalSeconds, 10) + healthCheckInterval = strconv.FormatInt(int64(*hc.IntervalSeconds), 10) } uuidHash := sha256.New() _, _ = uuidHash.Write([]byte(t.clusterName)) @@ -263,12 +263,12 @@ func (t *defaultModelBuildTask) buildPreserveClientIPFlag(_ context.Context, tar // buildTargetGroupPort constructs the TargetGroup's port. // Note: TargetGroup's port is not in the data path as we always register targets with port specified. // so this setting don't really matter to our controller, and we do our best to use the most appropriate port as targetGroup's port to avoid UX confusion. -func (t *defaultModelBuildTask) buildTargetGroupPort(_ context.Context, targetType elbv2model.TargetType, svcPort corev1.ServicePort) int64 { +func (t *defaultModelBuildTask) buildTargetGroupPort(_ context.Context, targetType elbv2model.TargetType, svcPort corev1.ServicePort) int32 { if targetType == elbv2model.TargetTypeInstance { - return int64(svcPort.NodePort) + return svcPort.NodePort } if svcPort.TargetPort.Type == intstr.Int { - return int64(svcPort.TargetPort.IntValue()) + return int32(svcPort.TargetPort.IntValue()) } // when a literal targetPort is used, we just use a fixed 1 here as this setting is not in the data path. @@ -334,36 +334,36 @@ func (t *defaultModelBuildTask) buildTargetGroupHealthCheckMatcher(_ context.Con } } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckIntervalSeconds(_ context.Context, defaultHealthCheckInterval int64) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckIntervalSeconds(_ context.Context, defaultHealthCheckInterval int32) (int32, error) { intervalSeconds := defaultHealthCheckInterval - if _, err := t.annotationParser.ParseInt64Annotation(annotations.SvcLBSuffixHCInterval, &intervalSeconds, t.service.Annotations); err != nil { + if _, err := t.annotationParser.ParseInt32Annotation(annotations.SvcLBSuffixHCInterval, &intervalSeconds, t.service.Annotations); err != nil { return 0, err } return intervalSeconds, nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckTimeoutSeconds(_ context.Context, defaultHealthCheckTimeout int64) (*int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckTimeoutSeconds(_ context.Context, defaultHealthCheckTimeout int32) (*int32, error) { timeoutSeconds := defaultHealthCheckTimeout if !t.featureGates.Enabled(config.NLBHealthCheckAdvancedConfig) { - return &timeoutSeconds, nil + return awssdk.Int32(timeoutSeconds), nil } - if _, err := t.annotationParser.ParseInt64Annotation(annotations.SvcLBSuffixHCTimeout, &timeoutSeconds, t.service.Annotations); err != nil { + if _, err := t.annotationParser.ParseInt32Annotation(annotations.SvcLBSuffixHCTimeout, &timeoutSeconds, t.service.Annotations); err != nil { return nil, err } - return &timeoutSeconds, nil + return awssdk.Int32(timeoutSeconds), nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckHealthyThresholdCount(_ context.Context, defaultHealthCheckHealthyThreshold int64) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckHealthyThresholdCount(_ context.Context, defaultHealthCheckHealthyThreshold int32) (int32, error) { healthyThresholdCount := defaultHealthCheckHealthyThreshold - if _, err := t.annotationParser.ParseInt64Annotation(annotations.SvcLBSuffixHCHealthyThreshold, &healthyThresholdCount, t.service.Annotations); err != nil { + if _, err := t.annotationParser.ParseInt32Annotation(annotations.SvcLBSuffixHCHealthyThreshold, &healthyThresholdCount, t.service.Annotations); err != nil { return 0, err } return healthyThresholdCount, nil } -func (t *defaultModelBuildTask) buildTargetGroupHealthCheckUnhealthyThresholdCount(_ context.Context, defaultHealthCheckUnhealthyThreshold int64) (int64, error) { +func (t *defaultModelBuildTask) buildTargetGroupHealthCheckUnhealthyThresholdCount(_ context.Context, defaultHealthCheckUnhealthyThreshold int32) (int32, error) { unhealthyThresholdCount := defaultHealthCheckUnhealthyThreshold - if _, err := t.annotationParser.ParseInt64Annotation(annotations.SvcLBSuffixHCUnhealthyThreshold, &unhealthyThresholdCount, t.service.Annotations); err != nil { + if _, err := t.annotationParser.ParseInt32Annotation(annotations.SvcLBSuffixHCUnhealthyThreshold, &unhealthyThresholdCount, t.service.Annotations); err != nil { return 0, err } return unhealthyThresholdCount, nil @@ -421,7 +421,7 @@ func (t *defaultModelBuildTask) buildTargetGroupBindingSpec(ctx context.Context, } var tgbNetworking *elbv2model.TargetGroupBindingNetworking if len(t.loadBalancer.Spec.SecurityGroups) == 0 { - tgbNetworking, err = t.buildTargetGroupBindingNetworkingLegacy(ctx, targetPort, *hc.Port, port, scheme, *targetGroup.Spec.IPAddressType) + tgbNetworking, err = t.buildTargetGroupBindingNetworkingLegacy(ctx, targetPort, *hc.Port, port, scheme, targetGroup.Spec.IPAddressType) } else { tgbNetworking, err = t.buildTargetGroupBindingNetworking(ctx, targetPort, *hc.Port, port) } @@ -443,7 +443,7 @@ func (t *defaultModelBuildTask) buildTargetGroupBindingSpec(ctx context.Context, }, Networking: tgbNetworking, NodeSelector: nodeSelector, - IPAddressType: (*elbv2api.TargetGroupIPAddressType)(targetGroup.Spec.IPAddressType), + IPAddressType: elbv2api.TargetGroupIPAddressType(targetGroup.Spec.IPAddressType), VpcID: t.vpcID, }, }, @@ -620,10 +620,10 @@ func (t *defaultModelBuildTask) getLoadBalancerSubnetsSourceRanges(targetGroupIP var subnetCIDRs []string for _, subnet := range t.ec2Subnets { if targetGroupIPAddressType == elbv2model.TargetGroupIPAddressTypeIPv4 { - subnetCIDRs = append(subnetCIDRs, aws.StringValue(subnet.CidrBlock)) + subnetCIDRs = append(subnetCIDRs, awssdk.ToString(subnet.CidrBlock)) } else { for _, ipv6CIDRBlockAssoc := range subnet.Ipv6CidrBlockAssociationSet { - subnetCIDRs = append(subnetCIDRs, aws.StringValue(ipv6CIDRBlockAssoc.Ipv6CidrBlock)) + subnetCIDRs = append(subnetCIDRs, awssdk.ToString(ipv6CIDRBlockAssoc.Ipv6CidrBlock)) } } } @@ -639,7 +639,7 @@ func (t *defaultModelBuildTask) buildTargetGroupIPAddressType(_ context.Context, } } if ipv6Configured { - if *t.loadBalancer.Spec.IPAddressType != elbv2model.IPAddressTypeDualStack { + if elbv2model.IPAddressTypeDualStack != t.loadBalancer.Spec.IPAddressType { return "", errors.New("unsupported IPv6 configuration, lb not dual-stack") } return elbv2model.TargetGroupIPAddressTypeIPv6, nil diff --git a/pkg/service/model_build_target_group_test.go b/pkg/service/model_build_target_group_test.go index 78bebd158c..7839f1dc28 100644 --- a/pkg/service/model_build_target_group_test.go +++ b/pkg/service/model_build_target_group_test.go @@ -3,6 +3,7 @@ package service import ( "context" "errors" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/golang/mock/gomock" "sigs.k8s.io/aws-load-balancer-controller/pkg/model/core" "sigs.k8s.io/aws-load-balancer-controller/pkg/networking" @@ -10,8 +11,7 @@ import ( "strconv" "testing" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ec2" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -185,11 +185,11 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &trafficPort, - Protocol: (*elbv2.Protocol)(aws.String(string(elbv2.ProtocolTCP))), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(10), - HealthyThresholdCount: aws.Int64(3), - UnhealthyThresholdCount: aws.Int64(3), + Protocol: elbv2.ProtocolTCP, + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(10), + HealthyThresholdCount: aws.Int32(3), + UnhealthyThresholdCount: aws.Int32(3), }, targetType: elbv2.TargetTypeIP, }, @@ -212,12 +212,12 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &port8888, - Protocol: (*elbv2.Protocol)(aws.String("HTTP")), + Protocol: elbv2.ProtocolHTTP, Path: aws.String("/healthz"), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(30), - HealthyThresholdCount: aws.Int64(2), - UnhealthyThresholdCount: aws.Int64(2), + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(30), + HealthyThresholdCount: aws.Int32(2), + UnhealthyThresholdCount: aws.Int32(2), Matcher: &elbv2.HealthCheckMatcher{ HTTPCode: aws.String("200-220,231,250-300,301,302"), }, @@ -236,12 +236,12 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &trafficPort, - Protocol: (*elbv2.Protocol)(aws.String("HTTP")), + Protocol: elbv2.ProtocolHTTP, Path: aws.String("/"), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(10), - HealthyThresholdCount: aws.Int64(3), - UnhealthyThresholdCount: aws.Int64(3), + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(10), + HealthyThresholdCount: aws.Int32(3), + UnhealthyThresholdCount: aws.Int32(3), Matcher: &elbv2.HealthCheckMatcher{ HTTPCode: aws.String("200-399"), }, @@ -296,11 +296,11 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &trafficPort, - Protocol: (*elbv2.Protocol)(aws.String(string(elbv2.ProtocolTCP))), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(10), - HealthyThresholdCount: aws.Int64(3), - UnhealthyThresholdCount: aws.Int64(3), + Protocol: elbv2.ProtocolTCP, + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(10), + HealthyThresholdCount: aws.Int32(3), + UnhealthyThresholdCount: aws.Int32(3), }, targetType: elbv2.TargetTypeIP, }, @@ -316,12 +316,12 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &port31223, - Protocol: (*elbv2.Protocol)(aws.String(string(elbv2.ProtocolHTTP))), + Protocol: elbv2.ProtocolHTTP, Path: aws.String("/healthz"), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(6), - HealthyThresholdCount: aws.Int64(2), - UnhealthyThresholdCount: aws.Int64(2), + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(6), + HealthyThresholdCount: aws.Int32(2), + UnhealthyThresholdCount: aws.Int32(2), Matcher: &elbv2.HealthCheckMatcher{ HTTPCode: aws.String("200-399"), }, @@ -350,11 +350,11 @@ func Test_defaultModelBuilderTask_buildTargetHealthCheck(t *testing.T) { wantError: false, wantValue: &elbv2.TargetGroupHealthCheckConfig{ Port: &port8888, - Protocol: (*elbv2.Protocol)(aws.String(string(elbv2.ProtocolTCP))), - IntervalSeconds: aws.Int64(10), - TimeoutSeconds: aws.Int64(30), - HealthyThresholdCount: aws.Int64(5), - UnhealthyThresholdCount: aws.Int64(5), + Protocol: elbv2.ProtocolTCP, + IntervalSeconds: aws.Int32(10), + TimeoutSeconds: aws.Int32(30), + HealthyThresholdCount: aws.Int32(5), + UnhealthyThresholdCount: aws.Int32(5), }, targetType: elbv2.TargetTypeInstance, }, @@ -403,7 +403,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes port80 := intstr.FromInt(80) port808 := intstr.FromInt(808) trafficPort := intstr.FromString("traffic-port") - cidrBlockStateAssociated := ec2.VpcCidrBlockStateCodeAssociated + cidrBlockStateAssociated := ec2types.VpcCidrBlockStateCodeAssociated type fetchVPCInfoCall struct { wantVPCInfo networking.VPCInfo err error @@ -414,7 +414,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc *corev1.Service tgPort intstr.IntOrString hcPort intstr.IntOrString - subnets []*ec2.Subnet + subnets []ec2types.Subnet tgProtocol corev1.Protocol ipAddressType elbv2.TargetGroupIPAddressType preserveClientIP bool @@ -432,7 +432,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes scheme: elbv2.LoadBalancerSchemeInternetFacing, tgPort: port80, hcPort: trafficPort, - subnets: []*ec2.Subnet{{ + subnets: []ec2types.Subnet{{ CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("az-1"), }}, @@ -490,7 +490,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes scheme: elbv2.LoadBalancerSchemeInternal, tgPort: port80, hcPort: port808, - subnets: []*ec2.Subnet{{ + subnets: []ec2types.Subnet{{ CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("az-1"), }}, @@ -542,7 +542,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes tgPort: port80, hcPort: port808, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{{ + subnets: []ec2types.Subnet{{ CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("az-1"), }}, @@ -589,24 +589,24 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes tgPort: port80, hcPort: port808, scheme: elbv2.LoadBalancerSchemeInternal, - subnets: []*ec2.Subnet{{ + subnets: []ec2types.Subnet{{ CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("az-1"), }}, fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: aws.String("172.16.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, { CidrBlock: aws.String("1.2.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -661,7 +661,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes tgPort: port80, hcPort: trafficPort, scheme: elbv2.LoadBalancerSchemeInternetFacing, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -703,7 +703,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc: &corev1.Service{}, tgPort: port80, hcPort: trafficPort, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -742,7 +742,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc: &corev1.Service{}, tgPort: port80, hcPort: trafficPort, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -759,17 +759,17 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { CidrBlock: aws.String("172.16.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, { CidrBlock: aws.String("1.2.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -806,7 +806,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc: &corev1.Service{}, tgPort: port80, hcPort: port808, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -868,7 +868,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, tgPort: port80, hcPort: port808, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -935,7 +935,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, tgPort: port80, hcPort: port80, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -1002,7 +1002,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, tgPort: port80, hcPort: port80, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("sn-1"), @@ -1050,10 +1050,10 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc: &corev1.Service{}, tgPort: port80, hcPort: port80, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1900::/56"), }, @@ -1062,7 +1062,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, { CidrBlock: aws.String("1.2.3.4/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2000:1ee3:5d0:fe00::/56"), }, @@ -1098,10 +1098,10 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes svc: &corev1.Service{}, tgPort: port80, hcPort: port80, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1900::/64"), }, @@ -1110,7 +1110,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, { CidrBlock: aws.String("1.2.3.4/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1901::/64"), }, @@ -1153,11 +1153,11 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - Ipv6CidrBlockAssociationSet: []*ec2.VpcIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.VpcIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1900::/56"), - Ipv6CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -1166,10 +1166,10 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, tgPort: port80, hcPort: port80, - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { CidrBlock: aws.String("172.16.0.0/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1900::/64"), }, @@ -1178,7 +1178,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, { CidrBlock: aws.String("1.2.3.4/19"), - Ipv6CidrBlockAssociationSet: []*ec2.SubnetIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.SubnetIpv6CidrBlockAssociation{ { Ipv6CidrBlock: aws.String("2300:1ab3:ab0:1901::/64"), }, @@ -1220,7 +1220,7 @@ func Test_defaultModelBuilderTask_buildTargetGroupBindingNetworkingLegacy(t *tes }, tgPort: port80, hcPort: port808, - subnets: []*ec2.Subnet{{ + subnets: []ec2types.Subnet{{ CidrBlock: aws.String("172.16.0.0/19"), SubnetId: aws.String("az-1"), }}, diff --git a/pkg/service/model_builder.go b/pkg/service/model_builder.go index 961254209b..9bd68c8cbc 100644 --- a/pkg/service/model_builder.go +++ b/pkg/service/model_builder.go @@ -2,10 +2,10 @@ package service import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "strconv" "sync" - "github.com/aws/aws-sdk-go/service/ec2" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -173,7 +173,7 @@ type defaultModelBuildTask struct { stack core.Stack loadBalancer *elbv2model.LoadBalancer tgByResID map[string]*elbv2model.TargetGroup - ec2Subnets []*ec2.Subnet + ec2Subnets []ec2types.Subnet enableBackendSG bool disableRestrictedSGRules bool backendSGIDToken core.StringToken @@ -196,10 +196,10 @@ type defaultModelBuildTask struct { defaultHealthCheckProtocol elbv2model.Protocol defaultHealthCheckPort string defaultHealthCheckPath string - defaultHealthCheckInterval int64 - defaultHealthCheckTimeout int64 - defaultHealthCheckHealthyThreshold int64 - defaultHealthCheckUnhealthyThreshold int64 + defaultHealthCheckInterval int32 + defaultHealthCheckTimeout int32 + defaultHealthCheckHealthyThreshold int32 + defaultHealthCheckUnhealthyThreshold int32 defaultHealthCheckMatcherHTTPCode string defaultDeletionProtectionEnabled bool defaultIPv4SourceRanges []string @@ -209,10 +209,10 @@ type defaultModelBuildTask struct { defaultHealthCheckProtocolForInstanceModeLocal elbv2model.Protocol defaultHealthCheckPortForInstanceModeLocal string defaultHealthCheckPathForInstanceModeLocal string - defaultHealthCheckIntervalForInstanceModeLocal int64 - defaultHealthCheckTimeoutForInstanceModeLocal int64 - defaultHealthCheckHealthyThresholdForInstanceModeLocal int64 - defaultHealthCheckUnhealthyThresholdForInstanceModeLocal int64 + defaultHealthCheckIntervalForInstanceModeLocal int32 + defaultHealthCheckTimeoutForInstanceModeLocal int32 + defaultHealthCheckHealthyThresholdForInstanceModeLocal int32 + defaultHealthCheckUnhealthyThresholdForInstanceModeLocal int32 } func (t *defaultModelBuildTask) run(ctx context.Context) error { diff --git a/pkg/service/model_builder_test.go b/pkg/service/model_builder_test.go index 4b598d80a9..998d46c1ab 100644 --- a/pkg/service/model_builder_test.go +++ b/pkg/service/model_builder_test.go @@ -2,12 +2,12 @@ package service import ( "context" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" "time" - "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/service/ec2" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -27,11 +27,11 @@ import ( func Test_defaultModelBuilderTask_Build(t *testing.T) { type resolveViaDiscoveryCall struct { - subnets []*ec2.Subnet + subnets []ec2types.Subnet err error } type resolveViaNameOrIDSliceCall struct { - subnets []*ec2.Subnet + subnets []ec2types.Subnet err error } type listLoadBalancerCall struct { @@ -47,56 +47,56 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { want []string err error } - cidrBlockStateAssociated := ec2.VpcCidrBlockStateCodeAssociated + cidrBlockStateAssociated := ec2types.VpcCidrBlockStateCodeAssociated resolveViaDiscoveryCallForOneSubnet := resolveViaDiscoveryCall{ - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, }, } resolveViaDiscoveryCallForTwoSubnet := resolveViaDiscoveryCall{ - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, { - SubnetId: aws.String("subnet-2"), - CidrBlock: aws.String("192.168.32.0/19"), + SubnetId: awssdk.String("subnet-2"), + CidrBlock: awssdk.String("192.168.32.0/19"), }, }, } resolveViaDiscoveryCallForThreeSubnet := resolveViaDiscoveryCall{ - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, { - SubnetId: aws.String("subnet-2"), - CidrBlock: aws.String("192.168.32.0/19"), + SubnetId: awssdk.String("subnet-2"), + CidrBlock: awssdk.String("192.168.32.0/19"), }, { - SubnetId: aws.String("subnet-3"), - CidrBlock: aws.String("192.168.64.0/19"), + SubnetId: awssdk.String("subnet-3"), + CidrBlock: awssdk.String("192.168.64.0/19"), }, }, } resolveViaNameOrIDSliceCallForThreeSubnet := resolveViaNameOrIDSliceCall{ - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, { - SubnetId: aws.String("subnet-2"), - CidrBlock: aws.String("192.168.32.0/19"), + SubnetId: awssdk.String("subnet-2"), + CidrBlock: awssdk.String("192.168.32.0/19"), }, { - SubnetId: aws.String("subnet-3"), - CidrBlock: aws.String("192.168.64.0/19"), + SubnetId: awssdk.String("subnet-3"), + CidrBlock: awssdk.String("192.168.64.0/19"), }, }, } @@ -1138,11 +1138,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.168.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.168.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -1419,8 +1419,8 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internet-facing"), + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), }, }, }, @@ -1896,17 +1896,17 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.160.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.160.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, { - CidrBlock: aws.String("100.64.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("100.64.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -2054,7 +2054,7 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { }, Spec: corev1.ServiceSpec{ Type: corev1.ServiceTypeLoadBalancer, - LoadBalancerClass: aws.String("service.k8s.aws/nlb"), + LoadBalancerClass: awssdk.String("service.k8s.aws/nlb"), Selector: map[string]string{"app": "hello"}, Ports: []corev1.ServicePort{ { @@ -2070,17 +2070,17 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.160.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.160.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, { - CidrBlock: aws.String("100.64.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("100.64.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -2211,7 +2211,7 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { }, { testName: "service with enableIPTargetType set to false and type IP", - enableIPTargetType: aws.Bool(false), + enableIPTargetType: awssdk.Bool(false), svc: &corev1.Service{ ObjectMeta: metav1.ObjectMeta{ Name: "traffic-local", @@ -2394,11 +2394,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - Ipv6CidrBlockAssociationSet: []*ec2.VpcIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.VpcIpv6CidrBlockAssociation{ { - Ipv6CidrBlock: aws.String("2600:1fe3:3c0:1d00::/56"), - Ipv6CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + Ipv6CidrBlock: awssdk.String("2600:1fe3:3c0:1d00::/56"), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -2731,7 +2731,7 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { }, Spec: corev1.ServiceSpec{ Type: corev1.ServiceTypeLoadBalancer, - LoadBalancerClass: aws.String("service.k8s.aws/nlb"), + LoadBalancerClass: awssdk.String("service.k8s.aws/nlb"), Selector: map[string]string{"app": "class"}, Ports: []corev1.ServicePort{ { @@ -2749,11 +2749,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.168.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.168.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -2907,10 +2907,10 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { }, resolveViaNameOrIDSliceCalls: []resolveViaNameOrIDSliceCall{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, }, }, @@ -2919,11 +2919,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internal"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internal"), + AvailabilityZones: []elbv2types.AvailabilityZone{ { - SubnetId: aws.String("subnet-1"), + SubnetId: awssdk.String("subnet-1"), }, }, }, @@ -4067,11 +4067,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.168.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.168.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -4383,9 +4383,9 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internet-facing"), - SecurityGroups: []*string{aws.String("sg-lb")}, + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), + SecurityGroups: []string{"sg-lb"}, }, }, }, @@ -4733,9 +4733,9 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internet-facing"), - SecurityGroups: []*string{aws.String("sg-lb")}, + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internet-facing"), + SecurityGroups: []string{"sg-lb"}, }, }, }, @@ -5057,10 +5057,10 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { disableRestrictedSGRules: true, resolveViaNameOrIDSliceCalls: []resolveViaNameOrIDSliceCall{ { - subnets: []*ec2.Subnet{ + subnets: []ec2types.Subnet{ { - SubnetId: aws.String("subnet-1"), - CidrBlock: aws.String("192.168.0.0/19"), + SubnetId: awssdk.String("subnet-1"), + CidrBlock: awssdk.String("192.168.0.0/19"), }, }, }, @@ -5069,8 +5069,8 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internal"), + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internal"), }, }, }, @@ -5237,17 +5237,17 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.160.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.160.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, { - CidrBlock: aws.String("100.64.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("100.64.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -5433,11 +5433,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - Ipv6CidrBlockAssociationSet: []*ec2.VpcIpv6CidrBlockAssociation{ + Ipv6CidrBlockAssociationSet: []ec2types.VpcIpv6CidrBlockAssociation{ { - Ipv6CidrBlock: aws.String("2600:1fe3:3c0:1d00::/56"), - Ipv6CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + Ipv6CidrBlock: awssdk.String("2600:1fe3:3c0:1d00::/56"), + Ipv6CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -5794,7 +5794,7 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { }, Spec: corev1.ServiceSpec{ Type: corev1.ServiceTypeLoadBalancer, - LoadBalancerClass: aws.String("service.k8s.aws/nlb"), + LoadBalancerClass: awssdk.String("service.k8s.aws/nlb"), Selector: map[string]string{"app": "class"}, Ports: []corev1.ServicePort{ { @@ -5812,11 +5812,11 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { fetchVPCInfoCalls: []fetchVPCInfoCall{ { wantVPCInfo: networking.VPCInfo{ - CidrBlockAssociationSet: []*ec2.VpcCidrBlockAssociation{ + CidrBlockAssociationSet: []ec2types.VpcCidrBlockAssociation{ { - CidrBlock: aws.String("192.168.0.0/16"), - CidrBlockState: &ec2.VpcCidrBlockState{ - State: &cidrBlockStateAssociated, + CidrBlock: awssdk.String("192.168.0.0/16"), + CidrBlockState: &ec2types.VpcCidrBlockState{ + State: cidrBlockStateAssociated, }, }, }, @@ -5988,14 +5988,14 @@ func Test_defaultModelBuilderTask_Build(t *testing.T) { { sdkLBs: []elbv2.LoadBalancerWithTags{ { - LoadBalancer: &elbv2sdk.LoadBalancer{ - Scheme: aws.String("internal"), - AvailabilityZones: []*elbv2sdk.AvailabilityZone{ + LoadBalancer: &elbv2types.LoadBalancer{ + Scheme: elbv2types.LoadBalancerSchemeEnum("internal"), + AvailabilityZones: []elbv2types.AvailabilityZone{ { - SubnetId: aws.String("subnet-1"), + SubnetId: awssdk.String("subnet-1"), }, }, - SecurityGroups: []*string{aws.String("sg-lb")}, + SecurityGroups: []string{"sg-lb"}, }, }, }, diff --git a/pkg/service/service_utils_test.go b/pkg/service/service_utils_test.go index 975271cb26..13b1deff0c 100644 --- a/pkg/service/service_utils_test.go +++ b/pkg/service/service_utils_test.go @@ -1,7 +1,7 @@ package service import ( - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" diff --git a/pkg/targetgroupbinding/networking_manager.go b/pkg/targetgroupbinding/networking_manager.go index f8199026de..21fa4b741f 100644 --- a/pkg/targetgroupbinding/networking_manager.go +++ b/pkg/targetgroupbinding/networking_manager.go @@ -4,13 +4,14 @@ import ( "context" libErrors "errors" "fmt" + "github.com/aws/smithy-go" "net" "strings" "sync" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + ec2sdk "github.com/aws/aws-sdk-go-v2/service/ec2" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -28,8 +29,8 @@ import ( const ( tgbNetworkingIPPermissionLabelKey = "elbv2.k8s.aws/targetGroupBinding" tgbNetworkingIPPermissionLabelValue = "shared" - defaultTgbMinPort = int64(0) - defaultTgbMaxPort = int64(65535) + defaultTgbMinPort = int32(0) + defaultTgbMaxPort = int32(65535) ) // NetworkingManager manages the networking for targetGroupBindings. @@ -263,13 +264,13 @@ func (m *defaultNetworkingManager) groupIngressPermsBySourceAndProtocolPerSG(_ c } permsFromIPRangeRulesPerSG[sgID] = append(permsFromIPRangeRulesPerSG[sgID], permission) } else { - protocol := awssdk.StringValue(permission.Permission.IpProtocol) + protocol := awssdk.ToString(permission.Permission.IpProtocol) if _, ok := permsByProtocolAndSourcePerSG[sgID][protocol]; !ok { permsByProtocolAndSourcePerSG[sgID][protocol] = make(map[string][]networking.IPPermissionInfo) } groupID := "" if len(permission.Permission.UserIdGroupPairs) == 1 { - groupID = awssdk.StringValue(permission.Permission.UserIdGroupPairs[0].GroupId) + groupID = awssdk.ToString(permission.Permission.UserIdGroupPairs[0].GroupId) } if _, ok := permsByProtocolAndSourcePerSG[sgID][protocol][groupID]; !ok { permsByProtocolAndSourcePerSG[sgID][protocol][groupID] = []networking.IPPermissionInfo{} @@ -299,20 +300,20 @@ func (m *defaultNetworkingManager) computeRestrictedIngressPermissionsPerSG(ctx } permForCurrGroup := perms[0] for _, perm := range perms { - if awssdk.Int64Value(perm.Permission.FromPort) == 0 && awssdk.Int64Value(perm.Permission.ToPort) == 0 { + if awssdk.ToInt32(perm.Permission.FromPort) == 0 && awssdk.ToInt32(perm.Permission.ToPort) == 0 { minPort = defaultTgbMinPort maxPort = defaultTgbMaxPort } else { - if awssdk.Int64Value(perm.Permission.FromPort) < minPort { - minPort = awssdk.Int64Value(perm.Permission.FromPort) + if awssdk.ToInt32(perm.Permission.FromPort) < minPort { + minPort = awssdk.ToInt32(perm.Permission.FromPort) } - if awssdk.Int64Value(perm.Permission.ToPort) > maxPort { - maxPort = awssdk.Int64Value(perm.Permission.ToPort) + if awssdk.ToInt32(perm.Permission.ToPort) > maxPort { + maxPort = awssdk.ToInt32(perm.Permission.ToPort) } } } - permForCurrGroup.Permission.FromPort = awssdk.Int64(minPort) - permForCurrGroup.Permission.ToPort = awssdk.Int64(maxPort) + permForCurrGroup.Permission.FromPort = awssdk.Int32(minPort) + permForCurrGroup.Permission.ToPort = awssdk.Int32(maxPort) restrictedPermByProtocolPerSG[sgID] = append(restrictedPermByProtocolPerSG[sgID], permForCurrGroup) } } @@ -384,8 +385,8 @@ func (m *defaultNetworkingManager) computeIngressPermissionsForTGBNetworking(ctx } type sdkFromToPortPair struct { - fromPort int64 - toPort int64 + fromPort int32 + toPort int32 } // computePermissionsForPeerPort computes the needed Inbound IPPermissions for specified peer and port. @@ -425,7 +426,7 @@ func (m *defaultNetworkingManager) computePermissionsForPeerPort(ctx context.Con groupID := peer.SecurityGroup.GroupID permissions := make([]networking.IPPermissionInfo, 0, len(sdkFromToPortPairs)) for _, portPair := range sdkFromToPortPairs { - permission := networking.NewGroupIDIPPermission(sdkProtocol, awssdk.Int64(portPair.fromPort), awssdk.Int64(portPair.toPort), groupID, permissionLabels) + permission := networking.NewGroupIDIPPermission(sdkProtocol, awssdk.Int32(portPair.fromPort), awssdk.Int32(portPair.toPort), groupID, permissionLabels) permissions = append(permissions, permission) } return permissions, nil @@ -441,9 +442,9 @@ func (m *defaultNetworkingManager) computePermissionsForPeerPort(ctx context.Con for _, portPair := range sdkFromToPortPairs { var permission networking.IPPermissionInfo if strings.Contains(cidr, ":") { - permission = networking.NewCIDRv6IPPermission(sdkProtocol, awssdk.Int64(portPair.fromPort), awssdk.Int64(portPair.toPort), cidr, permissionLabels) + permission = networking.NewCIDRv6IPPermission(sdkProtocol, awssdk.Int32(portPair.fromPort), awssdk.Int32(portPair.toPort), cidr, permissionLabels) } else { - permission = networking.NewCIDRIPPermission(sdkProtocol, awssdk.Int64(portPair.fromPort), awssdk.Int64(portPair.toPort), cidr, permissionLabels) + permission = networking.NewCIDRIPPermission(sdkProtocol, awssdk.Int32(portPair.fromPort), awssdk.Int32(portPair.toPort), cidr, permissionLabels) } permissions = append(permissions, permission) } @@ -455,21 +456,21 @@ func (m *defaultNetworkingManager) computePermissionsForPeerPort(ctx context.Con // computeNumericalPorts computes the numerical ports if a named is used. // Note: multiple numerical ports can be returned since same named port might corresponding to different numerical ports on different pods. -func (m *defaultNetworkingManager) computeNumericalPorts(_ context.Context, port intstr.IntOrString, pods []k8s.PodInfo) ([]int64, error) { +func (m *defaultNetworkingManager) computeNumericalPorts(_ context.Context, port intstr.IntOrString, pods []k8s.PodInfo) ([]int32, error) { if port.Type == intstr.Int { - return []int64{int64(port.IntVal)}, nil + return []int32{port.IntVal}, nil } if len(pods) == 0 { return nil, errors.Errorf("named ports can only be used with pod endpoints") } - containerPorts := sets.NewInt64() + containerPorts := sets.NewInt32() for _, pod := range pods { containerPort, err := pod.LookupContainerPort(port) if err != nil { return nil, err } - containerPorts.Insert(containerPort) + containerPorts.Insert(int32(containerPort)) } return containerPorts.List(), nil } @@ -587,14 +588,14 @@ func (m *defaultNetworkingManager) unTrackEndpointSGs(_ context.Context, sgIDs . func (m *defaultNetworkingManager) fetchEndpointSGsFromAWS(ctx context.Context) ([]string, error) { clusterResourceTagKey := fmt.Sprintf("kubernetes.io/cluster/%s", m.clusterName) req := &ec2sdk.DescribeSecurityGroupsInput{ - Filters: []*ec2sdk.Filter{ + Filters: []ec2types.Filter{ { Name: awssdk.String("tag:" + clusterResourceTagKey), - Values: awssdk.StringSlice([]string{"owned", "shared"}), + Values: []string{"owned", "shared"}, }, { Name: awssdk.String("vpc-id"), - Values: awssdk.StringSlice([]string{m.vpcID}), + Values: []string{m.vpcID}, }, }, } @@ -606,9 +607,9 @@ func (m *defaultNetworkingManager) fetchEndpointSGsFromAWS(ctx context.Context) } func isEC2SecurityGroupNotFoundError(err error) bool { - var awsErr awserr.Error - if errors.As(err, &awsErr) { - return awsErr.Code() == "InvalidGroup.NotFound" + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + return apiErr.ErrorCode() == "InvalidGroup.NotFound" } return false } diff --git a/pkg/targetgroupbinding/networking_manager_test.go b/pkg/targetgroupbinding/networking_manager_test.go index 18f3c6b7ed..74482a8439 100644 --- a/pkg/targetgroupbinding/networking_manager_test.go +++ b/pkg/targetgroupbinding/networking_manager_test.go @@ -3,10 +3,10 @@ package targetgroupbinding import ( "context" "errors" + ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - ec2sdk "github.com/aws/aws-sdk-go/service/ec2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" corev1 "k8s.io/api/core/v1" @@ -54,11 +54,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -101,11 +101,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -115,11 +115,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * Labels: map[string]string{tgbNetworkingIPPermissionLabelKey: tgbNetworkingIPPermissionLabelValue}, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -129,11 +129,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * Labels: map[string]string{tgbNetworkingIPPermissionLabelKey: tgbNetworkingIPPermissionLabelValue}, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), CidrIp: awssdk.String("192.168.1.1/16"), @@ -143,11 +143,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * Labels: map[string]string{tgbNetworkingIPPermissionLabelKey: tgbNetworkingIPPermissionLabelValue}, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + IpRanges: []ec2types.IpRange{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), CidrIp: awssdk.String("192.168.1.1/16"), @@ -196,11 +196,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -210,11 +210,11 @@ func Test_defaultNetworkingManager_computeIngressPermissionsForTGBNetworking(t * Labels: map[string]string{tgbNetworkingIPPermissionLabelKey: tgbNetworkingIPPermissionLabelValue}, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + IpRanges: []ec2types.IpRange{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), CidrIp: awssdk.String("192.168.1.1/16"), @@ -271,11 +271,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -302,11 +302,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.1.1/16"), Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), @@ -333,11 +333,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - Ipv6Ranges: []*ec2sdk.Ipv6Range{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + Ipv6Ranges: []ec2types.Ipv6Range{ { CidrIpv6: awssdk.String("2002::1234:abcd:ffff:c0a8:101/64"), Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), @@ -383,11 +383,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(80), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(80), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -397,11 +397,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { Labels: map[string]string{tgbNetworkingIPPermissionLabelKey: tgbNetworkingIPPermissionLabelValue}, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -428,11 +428,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -458,11 +458,11 @@ func Test_defaultNetworkingManager_computePermissionsForPeerPort(t *testing.T) { }, want: []networking.IPPermissionInfo{ { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ { Description: awssdk.String("elbv2.k8s.aws/targetGroupBinding=shared"), GroupId: awssdk.String("sg-abcdefg"), @@ -496,7 +496,7 @@ func Test_defaultNetworkingManager_computeNumericalPorts(t *testing.T) { tests := []struct { name string args args - want []int64 + want []int32 wantErr error }{ { @@ -505,7 +505,7 @@ func Test_defaultNetworkingManager_computeNumericalPorts(t *testing.T) { port: intstr.FromInt(8080), pods: nil, }, - want: []int64{8080}, + want: []int32{8080}, }, { name: "named port resolves to same numerical port", @@ -532,7 +532,7 @@ func Test_defaultNetworkingManager_computeNumericalPorts(t *testing.T) { }, }, }, - want: []int64{80}, + want: []int32{80}, }, { name: "named port resolves to different numerical port", @@ -559,7 +559,7 @@ func Test_defaultNetworkingManager_computeNumericalPorts(t *testing.T) { }, }, }, - want: []int64{80, 8080}, + want: []int32{80, 8080}, }, { name: "numerical port cannot be used without pods", @@ -600,11 +600,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -612,11 +612,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -626,11 +626,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -644,11 +644,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -656,11 +656,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -670,11 +670,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -691,11 +691,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -703,11 +703,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -717,11 +717,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -733,11 +733,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t types.NamespacedName{Namespace: "ns-1", Name: "tgb-2"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -745,11 +745,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -759,11 +759,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-c": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -777,11 +777,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -789,11 +789,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -801,11 +801,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -815,11 +815,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -829,11 +829,11 @@ func Test_defaultNetworkingManager_computeUnrestrictedIngressPermissionsPerSG(t }, "sg-c": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -878,11 +878,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), FromPort: nil, ToPort: nil, - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -894,11 +894,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -914,11 +914,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), FromPort: nil, ToPort: nil, - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -928,11 +928,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-2"}: { "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), FromPort: nil, ToPort: nil, - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -944,11 +944,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -957,11 +957,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -977,11 +977,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -993,11 +993,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1013,11 +1013,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1027,11 +1027,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-2"}: { "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -1043,11 +1043,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1056,11 +1056,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(0), - ToPort: awssdk.Int64(65535), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(0), + ToPort: awssdk.Int32(65535), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -1076,21 +1076,21 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(30), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(30), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1102,11 +1102,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(30), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(30), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1122,21 +1122,21 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(30), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(30), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1144,21 +1144,21 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -1170,11 +1170,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(30), - ToPort: awssdk.Int64(8080), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(30), + ToPort: awssdk.Int32(8080), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1183,11 +1183,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("udp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8443), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8443), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-2")}, }, }, @@ -1202,11 +1202,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(80), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(80), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -1214,11 +1214,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -1226,11 +1226,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -1244,11 +1244,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(80), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(80), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -1256,11 +1256,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -1268,11 +1268,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(8443), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(8443), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -1289,11 +1289,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t types.NamespacedName{Namespace: "ns-1", Name: "tgb-1"}: { "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(80), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(80), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -1301,11 +1301,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -1313,11 +1313,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -1327,21 +1327,21 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(9090), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(9090), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(32768), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(32768), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, @@ -1353,11 +1353,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t want: map[string][]networking.IPPermissionInfo{ "sg-a": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(80), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(80), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.168.0.0/16"), }, @@ -1365,11 +1365,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8080), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(8080), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.169.0.0/16"), }, @@ -1377,11 +1377,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, }, { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(80), - ToPort: awssdk.Int64(8080), - IpRanges: []*ec2sdk.IpRange{ + FromPort: awssdk.Int32(80), + ToPort: awssdk.Int32(8080), + IpRanges: []ec2types.IpRange{ { CidrIp: awssdk.String("192.170.0.0/16"), }, @@ -1391,11 +1391,11 @@ func Test_defaultNetworkingManager_computeRestrictedIngressPermissionsPerSG(t *t }, "sg-b": { { - Permission: ec2sdk.IpPermission{ + Permission: ec2types.IpPermission{ IpProtocol: awssdk.String("tcp"), - FromPort: awssdk.Int64(8443), - ToPort: awssdk.Int64(32768), - UserIdGroupPairs: []*ec2sdk.UserIdGroupPair{ + FromPort: awssdk.Int32(8443), + ToPort: awssdk.Int32(32768), + UserIdGroupPairs: []ec2types.UserIdGroupPair{ {GroupId: awssdk.String("group-1")}, }, }, diff --git a/pkg/targetgroupbinding/resource_manager.go b/pkg/targetgroupbinding/resource_manager.go index 7f92166254..3b261b2ab6 100644 --- a/pkg/targetgroupbinding/resource_manager.go +++ b/pkg/targetgroupbinding/resource_manager.go @@ -3,14 +3,14 @@ package targetgroupbinding import ( "context" "fmt" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" + "github.com/aws/smithy-go" "net/netip" "time" "k8s.io/client-go/tools/record" - awssdk "github.com/aws/aws-sdk-go/aws" - "github.com/aws/aws-sdk-go/aws/awserr" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" corev1 "k8s.io/api/core/v1" @@ -257,9 +257,9 @@ func (m *defaultResourceManager) updateTargetHealthPodCondition(ctx context.Cont for _, endpoint := range unmatchedEndpoints { pod := endpoint.Pod - targetHealth := &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), + targetHealth := &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumInitial, + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, Description: awssdk.String("Target registration is in progress"), } needFurtherProbe, err := m.updateTargetHealthPodConditionForPod(ctx, pod, targetHealth, targetHealthCondType) @@ -276,7 +276,7 @@ func (m *defaultResourceManager) updateTargetHealthPodCondition(ctx context.Cont // updateTargetHealthPodConditionForPod updates pod's targetHealth condition for a single pod and its matched target. // returns whether further probe is needed or not. func (m *defaultResourceManager) updateTargetHealthPodConditionForPod(ctx context.Context, pod k8s.PodInfo, - targetHealth *elbv2sdk.TargetHealth, targetHealthCondType corev1.PodConditionType) (bool, error) { + targetHealth *elbv2types.TargetHealth, targetHealthCondType corev1.PodConditionType) (bool, error) { if !pod.HasAnyOfReadinessGates([]corev1.PodConditionType{targetHealthCondType}) { return false, nil } @@ -284,14 +284,14 @@ func (m *defaultResourceManager) updateTargetHealthPodConditionForPod(ctx contex targetHealthCondStatus := corev1.ConditionUnknown var reason, message string if targetHealth != nil { - if awssdk.StringValue(targetHealth.State) == elbv2sdk.TargetHealthStateEnumHealthy { + if string(targetHealth.State) == string(elbv2types.TargetHealthStateEnumHealthy) { targetHealthCondStatus = corev1.ConditionTrue } else { targetHealthCondStatus = corev1.ConditionFalse } - reason = awssdk.StringValue(targetHealth.Reason) - message = awssdk.StringValue(targetHealth.Description) + reason = string(targetHealth.Reason) + message = awssdk.ToString(targetHealth.Description) } needFurtherProbe := targetHealthCondStatus != corev1.ConditionTrue @@ -362,8 +362,8 @@ func (m *defaultResourceManager) updatePodAsHealthyForDeletedTGB(ctx context.Con continue } if pod.HasAnyOfReadinessGates([]corev1.PodConditionType{targetHealthCondType}) { - targetHealth := &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + targetHealth := &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, Description: awssdk.String("Target Group Binding is deleted"), } _, err := m.updateTargetHealthPodConditionForPod(ctx, pod, targetHealth, targetHealthCondType) @@ -376,7 +376,7 @@ func (m *defaultResourceManager) updatePodAsHealthyForDeletedTGB(ctx context.Con } func (m *defaultResourceManager) deregisterTargets(ctx context.Context, tgARN string, targets []TargetInfo) error { - sdkTargets := make([]elbv2sdk.TargetDescription, 0, len(targets)) + sdkTargets := make([]elbv2types.TargetDescription, 0, len(targets)) for _, target := range targets { sdkTargets = append(sdkTargets, target.Target) } @@ -403,11 +403,11 @@ func (m *defaultResourceManager) registerPodEndpoints(ctx context.Context, tgARN return err } - sdkTargets := make([]elbv2sdk.TargetDescription, 0, len(endpoints)) + sdkTargets := make([]elbv2types.TargetDescription, 0, len(endpoints)) for _, endpoint := range endpoints { - target := elbv2sdk.TargetDescription{ + target := elbv2types.TargetDescription{ Id: awssdk.String(endpoint.IP), - Port: awssdk.Int64(endpoint.Port), + Port: endpoint.Port, } podIP, err := netip.ParseAddr(endpoint.IP) if err != nil { @@ -422,11 +422,11 @@ func (m *defaultResourceManager) registerPodEndpoints(ctx context.Context, tgARN } func (m *defaultResourceManager) registerNodePortEndpoints(ctx context.Context, tgARN string, endpoints []backend.NodePortEndpoint) error { - sdkTargets := make([]elbv2sdk.TargetDescription, 0, len(endpoints)) + sdkTargets := make([]elbv2types.TargetDescription, 0, len(endpoints)) for _, endpoint := range endpoints { - sdkTargets = append(sdkTargets, elbv2sdk.TargetDescription{ + sdkTargets = append(sdkTargets, elbv2types.TargetDescription{ Id: awssdk.String(endpoint.InstanceID), - Port: awssdk.Int64(endpoint.Port), + Port: endpoint.Port, }) } return m.targetsManager.RegisterTargets(ctx, tgARN, sdkTargets) @@ -471,7 +471,7 @@ func matchPodEndpointWithTargets(endpoints []backend.PodEndpoint, targets []Targ } targetsByUID := make(map[string]TargetInfo, len(targets)) for _, target := range targets { - targetUID := fmt.Sprintf("%v:%v", awssdk.StringValue(target.Target.Id), awssdk.Int64Value(target.Target.Port)) + targetUID := fmt.Sprintf("%v:%v", awssdk.ToString(target.Target.Id), awssdk.ToInt32(target.Target.Port)) targetsByUID[targetUID] = target } endpointUIDs := sets.StringKeySet(endpointsByUID) @@ -510,7 +510,7 @@ func matchNodePortEndpointWithTargets(endpoints []backend.NodePortEndpoint, targ } targetsByUID := make(map[string]TargetInfo, len(targets)) for _, target := range targets { - targetUID := fmt.Sprintf("%v:%v", awssdk.StringValue(target.Target.Id), awssdk.Int64Value(target.Target.Port)) + targetUID := fmt.Sprintf("%v:%v", awssdk.ToString(target.Target.Id), awssdk.ToInt32(target.Target.Port)) targetsByUID[targetUID] = target } endpointUIDs := sets.StringKeySet(endpointsByUID) @@ -533,17 +533,23 @@ func matchNodePortEndpointWithTargets(endpoints []backend.NodePortEndpoint, targ } func isELBV2TargetGroupNotFoundError(err error) bool { - var awsErr awserr.Error + var awsErr *elbv2types.TargetGroupNotFoundException if errors.As(err, &awsErr) { - return awsErr.Code() == "TargetGroupNotFound" + return true } return false } func isELBV2TargetGroupARNInvalidError(err error) bool { - var awsErr awserr.Error + var awsErr *elbv2types.InvalidTargetException if errors.As(err, &awsErr) { - return awsErr.Code() == "ValidationError" + return true + } + var apiErr smithy.APIError + if errors.As(err, &apiErr) { + code := apiErr.ErrorCode() + + return code == "ValidationError" } return false } diff --git a/pkg/targetgroupbinding/resource_manager_test.go b/pkg/targetgroupbinding/resource_manager_test.go index bfc9bdd3b1..1031c1e530 100644 --- a/pkg/targetgroupbinding/resource_manager_test.go +++ b/pkg/targetgroupbinding/resource_manager_test.go @@ -2,10 +2,10 @@ package targetgroupbinding import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/google/go-cmp/cmp" "github.com/google/go-cmp/cmp/cmpopts" @@ -28,7 +28,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing type args struct { pod k8s.PodInfo - targetHealth *elbv2sdk.TargetHealth + targetHealth *elbv2types.TargetHealth targetHealthCondType corev1.PodConditionType } @@ -84,8 +84,8 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing }, }, }, - targetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + targetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, targetHealthCondType: "target-health.elbv2.k8s.aws/my-tgb", }, @@ -138,7 +138,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing Conditions: []corev1.PodCondition{ { Type: "target-health.elbv2.k8s.aws/my-tgb", - Message: elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress, + Message: string(elbv2types.TargetHealthReasonEnumRegistrationInProgress), Reason: "Elb.RegistrationInProgress", Status: corev1.ConditionFalse, }, @@ -163,7 +163,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing Conditions: []corev1.PodCondition{ { Type: "target-health.elbv2.k8s.aws/my-tgb", - Message: elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress, + Message: string(elbv2types.TargetHealthReasonEnumRegistrationInProgress), Reason: "Elb.RegistrationInProgress", Status: corev1.ConditionFalse, }, @@ -173,8 +173,8 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing }, }, }, - targetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + targetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, targetHealthCondType: "target-health.elbv2.k8s.aws/my-tgb", }, @@ -228,7 +228,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing { Type: "target-health.elbv2.k8s.aws/my-tgb", Status: corev1.ConditionFalse, - Reason: elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress, + Reason: string(elbv2types.TargetHealthReasonEnumRegistrationInProgress), Message: "Target registration is in progress", }, { @@ -253,7 +253,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing { Type: "target-health.elbv2.k8s.aws/my-tgb", Status: corev1.ConditionFalse, - Reason: elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress, + Reason: string(elbv2types.TargetHealthReasonEnumRegistrationInProgress), Message: "Target registration is in progress", }, { @@ -262,9 +262,9 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing }, }, }, - targetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetFailedHealthChecks), + targetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumUnhealthy, + Reason: elbv2types.TargetHealthReasonEnumFailedHealthChecks, Description: awssdk.String("Health checks failed"), }, targetHealthCondType: "target-health.elbv2.k8s.aws/my-tgb", @@ -288,7 +288,7 @@ func Test_defaultResourceManager_updateTargetHealthPodConditionForPod(t *testing { Type: "target-health.elbv2.k8s.aws/my-tgb", Status: corev1.ConditionFalse, - Reason: elbv2sdk.TargetHealthReasonEnumTargetFailedHealthChecks, + Reason: string(elbv2types.TargetHealthReasonEnumFailedHealthChecks), Message: "Health checks failed", }, { @@ -429,9 +429,9 @@ func Test_containsTargetsInInitialState(t *testing.T) { matchedEndpointAndTargets: []podEndpointAndTargetPair{ { target: TargetInfo{ - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumInitial, + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, Description: awssdk.String("Target registration is in progress"), }, }, @@ -446,8 +446,8 @@ func Test_containsTargetsInInitialState(t *testing.T) { matchedEndpointAndTargets: []podEndpointAndTargetPair{ { target: TargetInfo{ - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, diff --git a/pkg/targetgroupbinding/targets_manager.go b/pkg/targetgroupbinding/targets_manager.go index f003e81962..b32eb350e0 100644 --- a/pkg/targetgroupbinding/targets_manager.go +++ b/pkg/targetgroupbinding/targets_manager.go @@ -2,8 +2,9 @@ package targetgroupbinding import ( "context" - "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "k8s.io/apimachinery/pkg/util/cache" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -20,10 +21,10 @@ const ( // TargetsManager is an abstraction around ELBV2's targets API. type TargetsManager interface { // Register Targets into TargetGroup. - RegisterTargets(ctx context.Context, tgARN string, targets []elbv2sdk.TargetDescription) error + RegisterTargets(ctx context.Context, tgARN string, targets []elbv2types.TargetDescription) error // Deregister Targets from TargetGroup. - DeregisterTargets(ctx context.Context, tgARN string, targets []elbv2sdk.TargetDescription) error + DeregisterTargets(ctx context.Context, tgARN string, targets []elbv2types.TargetDescription) error // List Targets from TargetGroup. ListTargets(ctx context.Context, tgARN string) ([]TargetInfo, error) @@ -75,7 +76,7 @@ type targetsCacheItem struct { targets []TargetInfo } -func (m *cachedTargetsManager) RegisterTargets(ctx context.Context, tgARN string, targets []elbv2sdk.TargetDescription) error { +func (m *cachedTargetsManager) RegisterTargets(ctx context.Context, tgARN string, targets []elbv2types.TargetDescription) error { targetsChunks := chunkTargetDescriptions(targets, m.registerTargetsChunkSize) for _, targetsChunk := range targetsChunks { req := &elbv2sdk.RegisterTargetsInput{ @@ -96,7 +97,7 @@ func (m *cachedTargetsManager) RegisterTargets(ctx context.Context, tgARN string return nil } -func (m *cachedTargetsManager) DeregisterTargets(ctx context.Context, tgARN string, targets []elbv2sdk.TargetDescription) error { +func (m *cachedTargetsManager) DeregisterTargets(ctx context.Context, tgARN string, targets []elbv2types.TargetDescription) error { targetsChunks := chunkTargetDescriptions(targets, m.deregisterTargetsChunkSize) for _, targetsChunk := range targetsChunks { req := &elbv2sdk.DeregisterTargetsInput{ @@ -159,7 +160,7 @@ func (m *cachedTargetsManager) refreshAllTargets(ctx context.Context, tgARN stri // we can do nothing from controller perspective when a healthy target becomes unhealthy. func (m *cachedTargetsManager) refreshUnhealthyTargets(ctx context.Context, tgARN string, cachedTargets []TargetInfo) ([]TargetInfo, error) { var refreshedTargets []TargetInfo - var unhealthyTargets []elbv2sdk.TargetDescription + var unhealthyTargets []elbv2types.TargetDescription for _, cachedTarget := range cachedTargets { if cachedTarget.IsHealthy() { refreshedTargets = append(refreshedTargets, cachedTarget) @@ -187,7 +188,7 @@ func (m *cachedTargetsManager) refreshUnhealthyTargets(ctx context.Context, tgAR // listTargetsFromAWS will list targets for TargetGroup using ELBV2API. // if specified targets is non-empty, only these targets will be listed. // otherwise, all targets for targetGroup will be listed. -func (m *cachedTargetsManager) listTargetsFromAWS(ctx context.Context, tgARN string, targets []elbv2sdk.TargetDescription) ([]TargetInfo, error) { +func (m *cachedTargetsManager) listTargetsFromAWS(ctx context.Context, tgARN string, targets []elbv2types.TargetDescription) ([]TargetInfo, error) { req := &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: aws.String(tgARN), Targets: pointerizeTargetDescriptions(targets), @@ -208,7 +209,7 @@ func (m *cachedTargetsManager) listTargetsFromAWS(ctx context.Context, tgARN str } // recordSuccessfulRegisterTargetsOperation will record a successful deregisterTarget operation -func (m *cachedTargetsManager) recordSuccessfulRegisterTargetsOperation(tgARN string, targets []elbv2sdk.TargetDescription) { +func (m *cachedTargetsManager) recordSuccessfulRegisterTargetsOperation(tgARN string, targets []elbv2types.TargetDescription) { m.targetsCacheMutex.RLock() rawTargetsCacheItem, exists := m.targetsCache.Get(tgARN) m.targetsCacheMutex.RUnlock() @@ -216,7 +217,7 @@ func (m *cachedTargetsManager) recordSuccessfulRegisterTargetsOperation(tgARN st if !exists { return } - targetsByUniqueID := make(map[string]elbv2sdk.TargetDescription, len(targets)) + targetsByUniqueID := make(map[string]elbv2types.TargetDescription, len(targets)) for _, target := range targets { targetsByUniqueID[UniqueIDForTargetDescription(target)] = target } @@ -241,7 +242,7 @@ func (m *cachedTargetsManager) recordSuccessfulRegisterTargetsOperation(tgARN st } // recordSuccessfulDeregisterTargetsOperation will record a successful deregisterTarget operation -func (m *cachedTargetsManager) recordSuccessfulDeregisterTargetsOperation(tgARN string, targets []elbv2sdk.TargetDescription) { +func (m *cachedTargetsManager) recordSuccessfulDeregisterTargetsOperation(tgARN string, targets []elbv2types.TargetDescription) { m.targetsCacheMutex.RLock() rawTargetsCacheItem, exists := m.targetsCache.Get(tgARN) m.targetsCacheMutex.RUnlock() @@ -249,7 +250,7 @@ func (m *cachedTargetsManager) recordSuccessfulDeregisterTargetsOperation(tgARN if !exists { return } - targetsByUniqueID := make(map[string]elbv2sdk.TargetDescription, len(targets)) + targetsByUniqueID := make(map[string]elbv2types.TargetDescription, len(targets)) for _, target := range targets { targetsByUniqueID[UniqueIDForTargetDescription(target)] = target } @@ -267,8 +268,8 @@ func (m *cachedTargetsManager) recordSuccessfulDeregisterTargetsOperation(tgARN } // chunkTargetDescriptions will split slice of TargetDescription into chunks -func chunkTargetDescriptions(targets []elbv2sdk.TargetDescription, chunkSize int) [][]elbv2sdk.TargetDescription { - var chunks [][]elbv2sdk.TargetDescription +func chunkTargetDescriptions(targets []elbv2types.TargetDescription, chunkSize int) [][]elbv2types.TargetDescription { + var chunks [][]elbv2types.TargetDescription for i := 0; i < len(targets); i += chunkSize { end := i + chunkSize if end > len(targets) { @@ -281,13 +282,13 @@ func chunkTargetDescriptions(targets []elbv2sdk.TargetDescription, chunkSize int // pointerizeTargetDescriptions converts slice of TargetDescription into slice of pointers to TargetDescription // if targets is empty or nil, nil will be returned. -func pointerizeTargetDescriptions(targets []elbv2sdk.TargetDescription) []*elbv2sdk.TargetDescription { +func pointerizeTargetDescriptions(targets []elbv2types.TargetDescription) []elbv2types.TargetDescription { if len(targets) == 0 { return nil } - result := make([]*elbv2sdk.TargetDescription, 0, len(targets)) + result := make([]elbv2types.TargetDescription, 0, len(targets)) for i := range targets { - result = append(result, &targets[i]) + result = append(result, targets[i]) } return result } diff --git a/pkg/targetgroupbinding/targets_manager_test.go b/pkg/targetgroupbinding/targets_manager_test.go index c10132bc9b..1a291ffd1e 100644 --- a/pkg/targetgroupbinding/targets_manager_test.go +++ b/pkg/targetgroupbinding/targets_manager_test.go @@ -2,8 +2,9 @@ package targetgroupbinding import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/golang/mock/gomock" "github.com/stretchr/testify/assert" "k8s.io/apimachinery/pkg/util/cache" @@ -27,7 +28,7 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { } type args struct { tgARN string - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string @@ -43,14 +44,14 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { { req: &elbv2sdk.RegisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -60,22 +61,22 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, }, @@ -83,39 +84,39 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -129,14 +130,14 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { { req: &elbv2sdk.RegisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -147,14 +148,14 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -167,14 +168,14 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { { req: &elbv2sdk.RegisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -183,14 +184,14 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { { req: &elbv2sdk.RegisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -203,52 +204,52 @@ func Test_cachedTargetsManager_RegisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -312,7 +313,7 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { } type args struct { tgARN string - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string @@ -328,14 +329,14 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { { req: &elbv2sdk.DeregisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -345,22 +346,22 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, }, @@ -368,32 +369,32 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -407,14 +408,14 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { { req: &elbv2sdk.DeregisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -425,14 +426,14 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -445,14 +446,14 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { { req: &elbv2sdk.DeregisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -461,14 +462,14 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { { req: &elbv2sdk.DeregisterTargetsInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -479,22 +480,22 @@ func Test_cachedTargetsManager_DeregisterTargets(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -575,14 +576,14 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { Targets: nil, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -596,24 +597,24 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -626,12 +627,12 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -642,24 +643,24 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -672,22 +673,22 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { { req: &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -697,22 +698,22 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -723,42 +724,42 @@ func Test_cachedTargetsManager_ListTargets(t *testing.T) { }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -837,42 +838,42 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { tgARN: "my-tg", cachedTargets: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -884,36 +885,36 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { { req: &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -925,45 +926,45 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { tgARN: "my-tg", cachedTargets: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -975,36 +976,36 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { { req: &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -1016,63 +1017,63 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { tgARN: "my-tg", cachedTargets: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, }, @@ -1084,37 +1085,37 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { { req: &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetNotRegistered), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnused), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumNotRegistered, + State: elbv2types.TargetHealthStateEnumUnused, }, }, }, @@ -1126,50 +1127,50 @@ func Test_cachedTargetsManager_refreshUnhealthyTargets(t *testing.T) { tgARN: "my-tg", cachedTargets: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, }, @@ -1211,7 +1212,7 @@ func Test_cachedTargetsManager_listTargetsFromAWS(t *testing.T) { type args struct { tgARN string - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string @@ -1227,23 +1228,23 @@ func Test_cachedTargetsManager_listTargetsFromAWS(t *testing.T) { { req: &elbv2sdk.DescribeTargetHealthInput{ TargetGroupArn: awssdk.String("my-tg"), - Targets: []*elbv2sdk.TargetDescription{ + Targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1253,22 +1254,22 @@ func Test_cachedTargetsManager_listTargetsFromAWS(t *testing.T) { }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1283,25 +1284,25 @@ func Test_cachedTargetsManager_listTargetsFromAWS(t *testing.T) { Targets: nil, }, resp: &elbv2sdk.DescribeTargetHealthOutput{ - TargetHealthDescriptions: []*elbv2sdk.TargetHealthDescription{ + TargetHealthDescriptions: []elbv2types.TargetHealthDescription{ { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: &elbv2sdk.TargetDescription{ + Target: &elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1315,23 +1316,23 @@ func Test_cachedTargetsManager_listTargetsFromAWS(t *testing.T) { }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1368,7 +1369,7 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi } type args struct { tgARN string - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string @@ -1383,10 +1384,10 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1398,13 +1399,13 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1412,19 +1413,19 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1436,13 +1437,13 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1450,29 +1451,29 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1484,23 +1485,23 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1508,39 +1509,39 @@ func Test_cachedTargetsManager_recordSuccessfulRegisterTargetsOperation(t *testi }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1580,7 +1581,7 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes } type args struct { tgARN string - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string @@ -1595,10 +1596,10 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1610,13 +1611,13 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1624,19 +1625,19 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1648,13 +1649,13 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1662,23 +1663,23 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1690,23 +1691,23 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes targetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, @@ -1714,33 +1715,33 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes }, args: args{ tgARN: "my-tg", - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, wantTargetsCache: map[string][]TargetInfo{ "my-tg": { { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1776,56 +1777,56 @@ func Test_cachedTargetsManager_recordSuccessfulDeregisterTargetsOperation(t *tes func Test_chunkTargetDescriptions(t *testing.T) { type args struct { - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription chunkSize int } tests := []struct { name string args args - want [][]elbv2sdk.TargetDescription + want [][]elbv2types.TargetDescription }{ { name: "can be evenly chunked", args: args{ - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, chunkSize: 2, }, - want: [][]elbv2sdk.TargetDescription{ + want: [][]elbv2types.TargetDescription{ { { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, { { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1833,46 +1834,46 @@ func Test_chunkTargetDescriptions(t *testing.T) { { name: "cannot be evenly chunked", args: args{ - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, chunkSize: 3, }, - want: [][]elbv2sdk.TargetDescription{ + want: [][]elbv2types.TargetDescription{ { { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, { { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1880,43 +1881,43 @@ func Test_chunkTargetDescriptions(t *testing.T) { { name: "chunkSize equal to total count", args: args{ - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, chunkSize: 4, }, - want: [][]elbv2sdk.TargetDescription{ + want: [][]elbv2types.TargetDescription{ { { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1924,43 +1925,43 @@ func Test_chunkTargetDescriptions(t *testing.T) { { name: "chunkSize greater than total count", args: args{ - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, chunkSize: 10, }, - want: [][]elbv2sdk.TargetDescription{ + want: [][]elbv2types.TargetDescription{ { { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.3"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.4"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -1976,7 +1977,7 @@ func Test_chunkTargetDescriptions(t *testing.T) { { name: "chunk empty slice", args: args{ - targets: []elbv2sdk.TargetDescription{}, + targets: []elbv2types.TargetDescription{}, chunkSize: 2, }, want: nil, @@ -1992,12 +1993,12 @@ func Test_chunkTargetDescriptions(t *testing.T) { func Test_pointerizeTargetDescriptions(t *testing.T) { type args struct { - targets []elbv2sdk.TargetDescription + targets []elbv2types.TargetDescription } tests := []struct { name string args args - want []*elbv2sdk.TargetDescription + want []elbv2types.TargetDescription }{ { name: "nil targets", @@ -2009,32 +2010,32 @@ func Test_pointerizeTargetDescriptions(t *testing.T) { { name: "empty targets", args: args{ - targets: []elbv2sdk.TargetDescription{}, + targets: []elbv2types.TargetDescription{}, }, want: nil, }, { name: "non-empty targets", args: args{ - targets: []elbv2sdk.TargetDescription{ + targets: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, - want: []*elbv2sdk.TargetDescription{ + want: []elbv2types.TargetDescription{ { Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, { Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, }, @@ -2075,40 +2076,40 @@ func Test_cloneTargetInfoSlice(t *testing.T) { args: args{ targets: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, }, want: []TargetInfo{ { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, { - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.2"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, }, diff --git a/pkg/targetgroupbinding/targets_manager_types.go b/pkg/targetgroupbinding/targets_manager_types.go index 838cf6d3c0..66d363988d 100644 --- a/pkg/targetgroupbinding/targets_manager_types.go +++ b/pkg/targetgroupbinding/targets_manager_types.go @@ -2,18 +2,18 @@ package targetgroupbinding import ( "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" ) // TargetInfo contains information about a TargetGroup target. type TargetInfo struct { // The target's description - Target elbv2sdk.TargetDescription + Target elbv2types.TargetDescription // The target's health information. // If absent, the target's health information is unknown. - TargetHealth *elbv2sdk.TargetHealth + TargetHealth *elbv2types.TargetHealth } // IsHealthy returns whether target is healthy. @@ -21,7 +21,7 @@ func (t *TargetInfo) IsHealthy() bool { if t.TargetHealth == nil { return false } - return awssdk.StringValue(t.TargetHealth.State) == elbv2sdk.TargetHealthStateEnumHealthy + return elbv2types.TargetHealthStateEnumHealthy == t.TargetHealth.State } // IsNotRegistered returns whether target is not registered. @@ -29,8 +29,8 @@ func (t *TargetInfo) IsNotRegistered() bool { if t.TargetHealth == nil { return false } - return awssdk.StringValue(t.TargetHealth.State) == elbv2sdk.TargetHealthStateEnumUnused && - awssdk.StringValue(t.TargetHealth.Reason) == elbv2sdk.TargetHealthReasonEnumTargetNotRegistered + return elbv2types.TargetHealthStateEnumUnused == t.TargetHealth.State && + elbv2types.TargetHealthReasonEnumNotRegistered == t.TargetHealth.Reason } // IsDraining returns whether target is in draining state. @@ -38,8 +38,8 @@ func (t *TargetInfo) IsDraining() bool { if t.TargetHealth == nil { return false } - return awssdk.StringValue(t.TargetHealth.State) == elbv2sdk.TargetHealthStateEnumDraining || - awssdk.StringValue(t.TargetHealth.State) == elbv2sdk.TargetHealthStateEnumUnhealthyDraining + return elbv2types.TargetHealthStateEnumDraining == t.TargetHealth.State || + elbv2types.TargetHealthStateEnumUnhealthyDraining == t.TargetHealth.State } // IsInitial returns whether target is in initial state. @@ -47,10 +47,10 @@ func (t *TargetInfo) IsInitial() bool { if t.TargetHealth == nil { return false } - return awssdk.StringValue(t.TargetHealth.State) == elbv2sdk.TargetHealthStateEnumInitial + return elbv2types.TargetHealthStateEnumInitial == t.TargetHealth.State } // UniqueIDForTargetDescription generates a unique ID to differentiate targets. -func UniqueIDForTargetDescription(target elbv2sdk.TargetDescription) string { - return fmt.Sprintf("%v:%v", awssdk.StringValue(target.Id), awssdk.Int64Value(target.Port)) +func UniqueIDForTargetDescription(target elbv2types.TargetDescription) string { + return fmt.Sprintf("%v:%v", awssdk.ToString(target.Id), awssdk.ToInt32(target.Port)) } diff --git a/pkg/targetgroupbinding/targets_manager_types_test.go b/pkg/targetgroupbinding/targets_manager_types_test.go index b062e83089..dd20335dd5 100644 --- a/pkg/targetgroupbinding/targets_manager_types_test.go +++ b/pkg/targetgroupbinding/targets_manager_types_test.go @@ -1,8 +1,8 @@ package targetgroupbinding import ( - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/stretchr/testify/assert" "testing" ) @@ -16,9 +16,9 @@ func TestTargetInfo_IsHealthy(t *testing.T) { { name: "target with unknown TargetHealth", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -27,13 +27,13 @@ func TestTargetInfo_IsHealthy(t *testing.T) { { name: "target with initial state and elbRegistrationInProgress reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, want: false, @@ -41,12 +41,12 @@ func TestTargetInfo_IsHealthy(t *testing.T) { { name: "target with healthy state", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - State: awssdk.String(elbv2sdk.TargetHealthStateEnumHealthy), + TargetHealth: &elbv2types.TargetHealth{ + State: elbv2types.TargetHealthStateEnumHealthy, }, }, want: true, @@ -54,13 +54,13 @@ func TestTargetInfo_IsHealthy(t *testing.T) { { name: "target with unhealthy state and targetTimeout reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetTimeout), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnhealthy), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumTimeout, + State: elbv2types.TargetHealthStateEnumUnhealthy, }, }, want: false, @@ -83,9 +83,9 @@ func TestTargetInfo_IsNotRegistered(t *testing.T) { { name: "target with unknown TargetHealth", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -94,13 +94,13 @@ func TestTargetInfo_IsNotRegistered(t *testing.T) { { name: "target with unused state and targetNotInUse reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetNotInUse), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnused), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumNotInUse, + State: elbv2types.TargetHealthStateEnumUnused, }, }, want: false, @@ -108,13 +108,13 @@ func TestTargetInfo_IsNotRegistered(t *testing.T) { { name: "target with unused state and targetNotRegistered reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetNotRegistered), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnused), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumNotRegistered, + State: elbv2types.TargetHealthStateEnumUnused, }, }, want: true, @@ -137,13 +137,13 @@ func TestTargetInfo_IsInitial(t *testing.T) { { name: "target with initial state and initial healthCheck reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbInitialHealthChecking), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumInitialHealthChecking, + State: elbv2types.TargetHealthStateEnumInitial, }, }, want: true, @@ -151,13 +151,13 @@ func TestTargetInfo_IsInitial(t *testing.T) { { name: "target with initial state and elb registrationInProgress reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumElbRegistrationInProgress), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumInitial), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumRegistrationInProgress, + State: elbv2types.TargetHealthStateEnumInitial, }, }, want: true, @@ -165,9 +165,9 @@ func TestTargetInfo_IsInitial(t *testing.T) { { name: "target with unknown TargetHealth", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, TargetHealth: nil, }, @@ -176,13 +176,13 @@ func TestTargetInfo_IsInitial(t *testing.T) { { name: "target with unused state and targetNotInUse reason", target: TargetInfo{ - Target: elbv2sdk.TargetDescription{ + Target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, - TargetHealth: &elbv2sdk.TargetHealth{ - Reason: awssdk.String(elbv2sdk.TargetHealthReasonEnumTargetNotInUse), - State: awssdk.String(elbv2sdk.TargetHealthStateEnumUnused), + TargetHealth: &elbv2types.TargetHealth{ + Reason: elbv2types.TargetHealthReasonEnumNotInUse, + State: elbv2types.TargetHealthStateEnumUnused, }, }, want: false, @@ -198,7 +198,7 @@ func TestTargetInfo_IsInitial(t *testing.T) { func TestUniqueIDForTargetDescription(t *testing.T) { type args struct { - target elbv2sdk.TargetDescription + target elbv2types.TargetDescription } tests := []struct { name string @@ -208,9 +208,9 @@ func TestUniqueIDForTargetDescription(t *testing.T) { { name: "instance target", args: args{ - target: elbv2sdk.TargetDescription{ + target: elbv2types.TargetDescription{ Id: awssdk.String("i-038a5c60b6c3c7799"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, want: "i-038a5c60b6c3c7799:8080", @@ -218,9 +218,9 @@ func TestUniqueIDForTargetDescription(t *testing.T) { { name: "instance target - with AZ info", args: args{ - target: elbv2sdk.TargetDescription{ + target: elbv2types.TargetDescription{ Id: awssdk.String("i-038a5c60b6c3c7799"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), AvailabilityZone: awssdk.String("all"), }, }, @@ -229,9 +229,9 @@ func TestUniqueIDForTargetDescription(t *testing.T) { { name: "ip target", args: args{ - target: elbv2sdk.TargetDescription{ + target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), }, }, want: "192.168.1.1:8080", @@ -239,9 +239,9 @@ func TestUniqueIDForTargetDescription(t *testing.T) { { name: "ip target - with AZ info", args: args{ - target: elbv2sdk.TargetDescription{ + target: elbv2types.TargetDescription{ Id: awssdk.String("192.168.1.1"), - Port: awssdk.Int64(8080), + Port: awssdk.Int32(8080), AvailabilityZone: awssdk.String("all"), }, }, diff --git a/scripts/gen_mocks.sh b/scripts/gen_mocks.sh index 5dadea1c4e..4e76837c72 100755 --- a/scripts/gen_mocks.sh +++ b/scripts/gen_mocks.sh @@ -4,9 +4,14 @@ MOCKGEN=${MOCKGEN:-~/go/bin/mockgen} $MOCKGEN -package=mock_client -destination=./mocks/controller-runtime/client/client_mocks.go sigs.k8s.io/controller-runtime/pkg/client Client +$MOCKGEN -package=services -destination=./pkg/aws/services/acm_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services ACM +$MOCKGEN -package=services -destination=./pkg/aws/services/ec2_metadata_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services EC2Metadata $MOCKGEN -package=services -destination=./pkg/aws/services/elbv2_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services ELBV2 $MOCKGEN -package=services -destination=./pkg/aws/services/ec2_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services EC2 +$MOCKGEN -package=services -destination=./pkg/aws/services/rgt_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services RGT $MOCKGEN -package=services -destination=./pkg/aws/services/shield_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services Shield +$MOCKGEN -package=services -destination=./pkg/aws/services/wafregional_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services WAFRegional +$MOCKGEN -package=services -destination=./pkg/aws/services/wafv2_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services WAFv2 $MOCKGEN -package=webhook -destination=./pkg/webhook/mutator_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/webhook Mutator $MOCKGEN -package=webhook -destination=./pkg/webhook/validator_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/webhook Validator $MOCKGEN -package=k8s -destination=./pkg/k8s/finalizer_mocks.go sigs.k8s.io/aws-load-balancer-controller/pkg/k8s FinalizerManager diff --git a/test/e2e/ingress/multi_path_backend.go b/test/e2e/ingress/multi_path_backend.go index 98303017f5..91b049b71c 100644 --- a/test/e2e/ingress/multi_path_backend.go +++ b/test/e2e/ingress/multi_path_backend.go @@ -5,7 +5,7 @@ import ( "fmt" "sync" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" networking "k8s.io/api/networking/v1" diff --git a/test/e2e/ingress/vanilla_ingress_test.go b/test/e2e/ingress/vanilla_ingress_test.go index 063ba4be04..f5366889de 100644 --- a/test/e2e/ingress/vanilla_ingress_test.go +++ b/test/e2e/ingress/vanilla_ingress_test.go @@ -7,7 +7,7 @@ import ( "strings" "time" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/gavv/httpexpect/v2" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" @@ -374,7 +374,7 @@ var _ = Describe("vanilla ingress tests", func() { sdkLB, err := tf.LBManager.GetLoadBalancerFromARN(ctx, lbARN) Expect(err).NotTo(HaveOccurred()) - Expect(awssdk.StringValue(sdkLB.LoadBalancerName)).Should(Equal(lbName)) + Expect(awssdk.ToString(sdkLB.LoadBalancerName)).Should(Equal(lbName)) // test traffic ExpectLBDNSBeAvailable(ctx, tf, lbARN, lbDNS) diff --git a/test/e2e/service/aws_resource_verifier.go b/test/e2e/service/aws_resource_verifier.go index 5846302852..990f5953f3 100644 --- a/test/e2e/service/aws_resource_verifier.go +++ b/test/e2e/service/aws_resource_verifier.go @@ -2,8 +2,8 @@ package service import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" . "github.com/onsi/gomega" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/test/framework" @@ -16,10 +16,10 @@ type TargetGroupHC struct { Protocol string Path string Port string - Interval int64 - Timeout int64 - HealthyThreshold int64 - UnhealthyThreshold int64 + Interval int32 + Timeout int32 + HealthyThreshold int32 + UnhealthyThreshold int32 } type LoadBalancerExpectation struct { @@ -47,16 +47,16 @@ func verifyAWSLoadBalancerResources(ctx context.Context, f *framework.Framework, return nil } -func verifyLoadBalancerName(_ context.Context, f *framework.Framework, lb *elbv2sdk.LoadBalancer, lbName string) error { +func verifyLoadBalancerName(_ context.Context, f *framework.Framework, lb *elbv2types.LoadBalancer, lbName string) error { if len(lbName) > 0 { - Expect(awssdk.StringValue(lb.LoadBalancerName)).To(Equal(lbName)) + Expect(awssdk.ToString(lb.LoadBalancerName)).To(Equal(lbName)) } return nil } -func verifyLoadBalancerType(_ context.Context, f *framework.Framework, lb *elbv2sdk.LoadBalancer, lbType, lbScheme string) error { - Expect(awssdk.StringValue(lb.Type)).To(Equal(lbType)) - Expect(awssdk.StringValue(lb.Scheme)).To(Equal(lbScheme)) +func verifyLoadBalancerType(_ context.Context, f *framework.Framework, lb *elbv2types.LoadBalancer, lbType, lbScheme string) error { + Expect(string(lb.Type)).To(Equal(lbType)) + Expect(string(lb.Scheme)).To(Equal(lbScheme)) return nil } @@ -64,8 +64,8 @@ func verifyLoadBalancerAttributes(ctx context.Context, f *framework.Framework, l lbAttrs, err := f.LBManager.GetLoadBalancerAttributes(ctx, lbARN) Expect(err).NotTo(HaveOccurred()) for _, attr := range lbAttrs { - if val, ok := expectedAttrs[awssdk.StringValue(attr.Key)]; ok && val != awssdk.StringValue(attr.Value) { - return errors.Errorf("Attribute %v, expected %v, actual %v", awssdk.StringValue(attr.Key), val, awssdk.StringValue(attr.Value)) + if val, ok := expectedAttrs[awssdk.ToString(attr.Key)]; ok && val != awssdk.ToString(attr.Value) { + return errors.Errorf("Attribute %v, expected %v, actual %v", awssdk.ToString(attr.Key), val, awssdk.ToString(attr.Value)) } } return nil @@ -78,20 +78,20 @@ func verifyLoadBalancerResourceTags(ctx context.Context, f *framework.Framework, Expect(err).NotTo(HaveOccurred()) for _, tg := range targetGroups { - resARNs = append(resARNs, awssdk.StringValue(tg.TargetGroupArn)) + resARNs = append(resARNs, awssdk.ToString(tg.TargetGroupArn)) } listeners, err := f.LBManager.GetLoadBalancerListeners(ctx, lbARN) Expect(err).NotTo(HaveOccurred()) for _, ls := range listeners { - resARNs = append(resARNs, awssdk.StringValue(ls.ListenerArn)) - rules, err := f.LBManager.GetLoadBalancerListenerRules(ctx, awssdk.StringValue(ls.ListenerArn)) + resARNs = append(resARNs, awssdk.ToString(ls.ListenerArn)) + rules, err := f.LBManager.GetLoadBalancerListenerRules(ctx, awssdk.ToString(ls.ListenerArn)) Expect(err).NotTo(HaveOccurred()) for _, rule := range rules { - if awssdk.BoolValue(rule.IsDefault) { + if awssdk.ToBool(rule.IsDefault) { continue } - resARNs = append(resARNs, awssdk.StringValue(rule.RuleArn)) + resARNs = append(resARNs, awssdk.ToString(rule.RuleArn)) } } for _, resARN := range resARNs { @@ -107,12 +107,12 @@ func matchResourceTags(ctx context.Context, f *framework.Framework, resARN strin Expect(err).NotTo(HaveOccurred()) matchedTags := 0 for _, tag := range lbTags { - if val, ok := expectedTags[awssdk.StringValue(tag.Key)]; ok && (val == "*" || val == awssdk.StringValue(tag.Value)) { + if val, ok := expectedTags[awssdk.ToString(tag.Key)]; ok && (val == "*" || val == awssdk.ToString(tag.Value)) { matchedTags++ } } for _, tag := range lbTags { - if val, ok := unexpectedTags[awssdk.StringValue(tag.Key)]; ok && (val == "*" || val == awssdk.StringValue(tag.Value)) { + if val, ok := unexpectedTags[awssdk.ToString(tag.Key)]; ok && (val == "*" || val == awssdk.ToString(tag.Value)) { return false } } @@ -124,8 +124,8 @@ func getLoadBalancerListenerProtocol(ctx context.Context, f *framework.Framework listeners, err := f.LBManager.GetLoadBalancerListeners(ctx, lbARN) Expect(err).ToNot(HaveOccurred()) for _, ls := range listeners { - if strconv.Itoa(int(awssdk.Int64Value(ls.Port))) == port { - protocol = awssdk.StringValue(ls.Protocol) + if strconv.Itoa(int(awssdk.ToInt32(ls.Port))) == port { + protocol = string(ls.Protocol) } } return protocol @@ -137,9 +137,9 @@ func verifyLoadBalancerListeners(ctx context.Context, f *framework.Framework, lb Expect(len(listeners)).To(Equal(len(listenersMap))) for _, ls := range listeners { - portStr := strconv.Itoa(int(awssdk.Int64Value(ls.Port))) + portStr := strconv.Itoa(int(awssdk.ToInt32(ls.Port))) Expect(listenersMap).Should(HaveKey(portStr)) - Expect(awssdk.StringValue(ls.Protocol)).To(Equal(listenersMap[portStr])) + Expect(string(ls.Protocol)).To(Equal(listenersMap[portStr])) } return nil } @@ -148,16 +148,16 @@ func verifyLoadBalancerListenerCertificates(ctx context.Context, f *framework.Fr listeners, err := f.LBManager.GetLoadBalancerListeners(ctx, lbARN) Expect(err).ToNot(HaveOccurred()) Expect(len(listeners)).Should(BeNumerically(">", 0)) - listenerCerts, err := f.LBManager.GetLoadBalancerListenerCertificates(ctx, awssdk.StringValue(listeners[0].ListenerArn)) + listenerCerts, err := f.LBManager.GetLoadBalancerListenerCertificates(ctx, awssdk.ToString(listeners[0].ListenerArn)) Expect(err).ToNot(HaveOccurred()) var observedCertArns []string var defaultCert string for _, cert := range listenerCerts { - if awssdk.BoolValue(cert.IsDefault) { - defaultCert = awssdk.StringValue(cert.CertificateArn) + if awssdk.ToBool(cert.IsDefault) { + defaultCert = awssdk.ToString(cert.CertificateArn) } - observedCertArns = append(observedCertArns, awssdk.StringValue(cert.CertificateArn)) + observedCertArns = append(observedCertArns, awssdk.ToString(cert.CertificateArn)) } if defaultCert != expectedCertARNS[0] { return errors.New("default cert does not match") @@ -177,25 +177,25 @@ func verifyLoadBalancerTargetGroups(ctx context.Context, f *framework.Framework, Expect(err).ToNot(HaveOccurred()) Expect(len(targetGroups)).To(Equal(len(expected.TargetGroups))) for _, tg := range targetGroups { - Expect(awssdk.StringValue(tg.TargetType)).To(Equal(expected.TargetType)) - Expect(awssdk.StringValue(tg.Protocol)).To(Equal(expected.TargetGroups[strconv.Itoa(int(awssdk.Int64Value(tg.Port)))])) + Expect(string(tg.TargetType)).To(Equal(expected.TargetType)) + Expect(string(tg.Protocol)).To(Equal(expected.TargetGroups[strconv.Itoa(int(awssdk.ToInt32(tg.Port)))])) err = verifyTargetGroupHealthCheckConfig(tg, expected.TargetGroupHC) Expect(err).NotTo(HaveOccurred()) - err = verifyTargetGroupNumRegistered(ctx, f, awssdk.StringValue(tg.TargetGroupArn), expected.NumTargets) + err = verifyTargetGroupNumRegistered(ctx, f, awssdk.ToString(tg.TargetGroupArn), expected.NumTargets) Expect(err).NotTo(HaveOccurred()) } return nil } -func verifyTargetGroupHealthCheckConfig(tg *elbv2sdk.TargetGroup, hc *TargetGroupHC) error { +func verifyTargetGroupHealthCheckConfig(tg elbv2types.TargetGroup, hc *TargetGroupHC) error { if hc != nil { - Expect(awssdk.StringValue(tg.HealthCheckProtocol)).To(Equal(hc.Protocol)) - Expect(awssdk.StringValue(tg.HealthCheckPath)).To(Equal(hc.Path)) - Expect(awssdk.StringValue(tg.HealthCheckPort)).To(Equal(hc.Port)) - Expect(awssdk.Int64Value(tg.HealthCheckIntervalSeconds)).To(Equal(hc.Interval)) - Expect(awssdk.Int64Value(tg.HealthCheckTimeoutSeconds)).To(Equal(hc.Timeout)) - Expect(awssdk.Int64Value(tg.HealthyThresholdCount)).To(Equal(hc.HealthyThreshold)) - Expect(awssdk.Int64Value(tg.UnhealthyThresholdCount)).To(Equal(hc.UnhealthyThreshold)) + Expect(string(tg.HealthCheckProtocol)).To(Equal(hc.Protocol)) + Expect(awssdk.ToString(tg.HealthCheckPath)).To(Equal(hc.Path)) + Expect(awssdk.ToString(tg.HealthCheckPort)).To(Equal(hc.Port)) + Expect(awssdk.ToInt32(tg.HealthCheckIntervalSeconds)).To(Equal(hc.Interval)) + Expect(awssdk.ToInt32(tg.HealthCheckTimeoutSeconds)).To(Equal(hc.Timeout)) + Expect(awssdk.ToInt32(tg.HealthyThresholdCount)).To(Equal(hc.HealthyThreshold)) + Expect(awssdk.ToInt32(tg.UnhealthyThresholdCount)).To(Equal(hc.UnhealthyThreshold)) } return nil } @@ -217,7 +217,7 @@ func waitUntilTargetsAreHealthy(ctx context.Context, f *framework.Framework, lbA Expect(err).ToNot(HaveOccurred()) Expect(len(targetGroups)).To(Not(BeZero())) // Check the first target group - tgARN := awssdk.StringValue(targetGroups[0].TargetGroupArn) + tgARN := awssdk.ToString(targetGroups[0].TargetGroupArn) Eventually(func() (bool, error) { return f.TGManager.CheckTargetGroupHealthy(ctx, tgARN, expectedTargetCount) @@ -228,7 +228,7 @@ func waitUntilTargetsAreHealthy(ctx context.Context, f *framework.Framework, lbA func getTargetGroupHealthCheckProtocol(ctx context.Context, f *framework.Framework, lbARN string) string { targetGroups, err := f.TGManager.GetTargetGroupsForLoadBalancer(ctx, lbARN) Expect(err).ToNot(HaveOccurred()) - return awssdk.StringValue(targetGroups[0].HealthCheckProtocol) + return string(targetGroups[0].HealthCheckProtocol) } func verifyTargetGroupAttributes(ctx context.Context, f *framework.Framework, lbARN string, expectedAttributes map[string]string) bool { @@ -236,12 +236,12 @@ func verifyTargetGroupAttributes(ctx context.Context, f *framework.Framework, lb Expect(err).ToNot(HaveOccurred()) Expect(len(targetGroups)).To(Not(BeZero())) // Check the first target group - tgARN := awssdk.StringValue(targetGroups[0].TargetGroupArn) + tgARN := awssdk.ToString(targetGroups[0].TargetGroupArn) tgAttrs, err := f.TGManager.GetTargetGroupAttributes(ctx, tgARN) Expect(err).NotTo(HaveOccurred()) matchedAttrs := 0 for _, attr := range tgAttrs { - if val, ok := expectedAttributes[awssdk.StringValue(attr.Key)]; ok && val == awssdk.StringValue(attr.Value) { + if val, ok := expectedAttributes[awssdk.ToString(attr.Key)]; ok && val == awssdk.ToString(attr.Value) { matchedAttrs++ } } diff --git a/test/e2e/service/nlb_instance_target_test.go b/test/e2e/service/nlb_instance_target_test.go index 54fe833d1f..29de0da564 100644 --- a/test/e2e/service/nlb_instance_target_test.go +++ b/test/e2e/service/nlb_instance_target_test.go @@ -5,7 +5,7 @@ import ( "fmt" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" . "github.com/onsi/ginkgo/v2" . "github.com/onsi/gomega" corev1 "k8s.io/api/core/v1" @@ -348,7 +348,7 @@ var _ = Describe("test k8s service reconciled by the aws load balancer controlle targetGroups, err := tf.TGManager.GetTargetGroupsForLoadBalancer(ctx, lbARN) Expect(err).ToNot(HaveOccurred()) Expect(len(targetGroups)).To(Equal(1)) - tgARN := awssdk.StringValue(targetGroups[0].TargetGroupArn) + tgARN := awssdk.ToString(targetGroups[0].TargetGroupArn) err = verifyTargetGroupNumRegistered(ctx, tf, tgARN, 1) Expect(err).ToNot(HaveOccurred()) @@ -360,7 +360,7 @@ var _ = Describe("test k8s service reconciled by the aws load balancer controlle targetGroups, err := tf.TGManager.GetTargetGroupsForLoadBalancer(ctx, lbARN) Expect(err).ToNot(HaveOccurred()) Expect(len(targetGroups)).To(Equal(1)) - tgARN := awssdk.StringValue(targetGroups[0].TargetGroupArn) + tgARN := awssdk.ToString(targetGroups[0].TargetGroupArn) nodes, err := stack.GetWorkerNodes(ctx, tf) Expect(err).ToNot(HaveOccurred()) diff --git a/test/framework/manifest/fixed_response_service_builder.go b/test/framework/manifest/fixed_response_service_builder.go index ed8a9ef205..d33d26f4d0 100644 --- a/test/framework/manifest/fixed_response_service_builder.go +++ b/test/framework/manifest/fixed_response_service_builder.go @@ -3,7 +3,7 @@ package manifest import ( "fmt" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" appsv1 "k8s.io/api/apps/v1" corev1 "k8s.io/api/core/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" diff --git a/test/framework/resources/aws/load_balancer.go b/test/framework/resources/aws/load_balancer.go index ae0060338e..e598332f38 100644 --- a/test/framework/resources/aws/load_balancer.go +++ b/test/framework/resources/aws/load_balancer.go @@ -2,8 +2,9 @@ package aws import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "github.com/pkg/errors" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -13,12 +14,12 @@ import ( type LoadBalancerManager interface { FindLoadBalancerByDNSName(ctx context.Context, dnsName string) (string, error) WaitUntilLoadBalancerAvailable(ctx context.Context, lbARN string) error - GetLoadBalancerFromARN(ctx context.Context, lbARN string) (*elbv2sdk.LoadBalancer, error) - GetLoadBalancerListeners(ctx context.Context, lbARN string) ([]*elbv2sdk.Listener, error) - GetLoadBalancerListenerCertificates(ctx context.Context, listenerARN string) ([]*elbv2sdk.Certificate, error) - GetLoadBalancerAttributes(ctx context.Context, lbARN string) ([]*elbv2sdk.LoadBalancerAttribute, error) - GetLoadBalancerResourceTags(ctx context.Context, resARN string) ([]*elbv2sdk.Tag, error) - GetLoadBalancerListenerRules(ctx context.Context, lsARN string) ([]*elbv2sdk.Rule, error) + GetLoadBalancerFromARN(ctx context.Context, lbARN string) (*elbv2types.LoadBalancer, error) + GetLoadBalancerListeners(ctx context.Context, lbARN string) ([]elbv2types.Listener, error) + GetLoadBalancerListenerCertificates(ctx context.Context, listenerARN string) ([]elbv2types.Certificate, error) + GetLoadBalancerAttributes(ctx context.Context, lbARN string) ([]elbv2types.LoadBalancerAttribute, error) + GetLoadBalancerResourceTags(ctx context.Context, resARN string) ([]elbv2types.Tag, error) + GetLoadBalancerListenerRules(ctx context.Context, lsARN string) ([]elbv2types.Rule, error) } // NewDefaultLoadBalancerManager constructs new defaultLoadBalancerManager. @@ -44,8 +45,8 @@ func (m *defaultLoadBalancerManager) FindLoadBalancerByDNSName(ctx context.Conte return "", err } for _, lb := range lbs { - if awssdk.StringValue(lb.DNSName) == dnsName { - return awssdk.StringValue(lb.LoadBalancerArn), nil + if awssdk.ToString(lb.DNSName) == dnsName { + return awssdk.ToString(lb.LoadBalancerArn), nil } } return "", errors.Errorf("couldn't find LoadBalancer with dnsName: %v", dnsName) @@ -53,14 +54,14 @@ func (m *defaultLoadBalancerManager) FindLoadBalancerByDNSName(ctx context.Conte func (m *defaultLoadBalancerManager) WaitUntilLoadBalancerAvailable(ctx context.Context, lbARN string) error { req := &elbv2sdk.DescribeLoadBalancersInput{ - LoadBalancerArns: awssdk.StringSlice([]string{lbARN}), + LoadBalancerArns: []string{lbARN}, } return m.elbv2Client.WaitUntilLoadBalancerAvailableWithContext(ctx, req) } -func (m *defaultLoadBalancerManager) GetLoadBalancerFromARN(ctx context.Context, lbARN string) (*elbv2sdk.LoadBalancer, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerFromARN(ctx context.Context, lbARN string) (*elbv2types.LoadBalancer, error) { req := &elbv2sdk.DescribeLoadBalancersInput{ - LoadBalancerArns: awssdk.StringSlice([]string{lbARN}), + LoadBalancerArns: []string{lbARN}, } lbs, err := m.elbv2Client.DescribeLoadBalancersWithContext(ctx, req) if err != nil { @@ -69,10 +70,10 @@ func (m *defaultLoadBalancerManager) GetLoadBalancerFromARN(ctx context.Context, if len(lbs.LoadBalancers) == 0 { return nil, errors.Errorf("couldn't find LoadBalancer with ARN %v", lbARN) } - return lbs.LoadBalancers[0], nil + return &lbs.LoadBalancers[0], nil } -func (m *defaultLoadBalancerManager) GetLoadBalancerListeners(ctx context.Context, lbARN string) ([]*elbv2sdk.Listener, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerListeners(ctx context.Context, lbARN string) ([]elbv2types.Listener, error) { listeners, err := m.elbv2Client.DescribeListenersWithContext(ctx, &elbv2sdk.DescribeListenersInput{ LoadBalancerArn: awssdk.String(lbARN), }) @@ -82,13 +83,13 @@ func (m *defaultLoadBalancerManager) GetLoadBalancerListeners(ctx context.Contex return listeners.Listeners, nil } -func (m *defaultLoadBalancerManager) GetLoadBalancerListenerCertificates(ctx context.Context, listenerARN string) ([]*elbv2sdk.Certificate, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerListenerCertificates(ctx context.Context, listenerARN string) ([]elbv2types.Certificate, error) { return m.elbv2Client.DescribeListenerCertificatesAsList(ctx, &elbv2sdk.DescribeListenerCertificatesInput{ ListenerArn: awssdk.String(listenerARN), }) } -func (m *defaultLoadBalancerManager) GetLoadBalancerAttributes(ctx context.Context, lbARN string) ([]*elbv2sdk.LoadBalancerAttribute, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerAttributes(ctx context.Context, lbARN string) ([]elbv2types.LoadBalancerAttribute, error) { resp, err := m.elbv2Client.DescribeLoadBalancerAttributesWithContext(ctx, &elbv2sdk.DescribeLoadBalancerAttributesInput{ LoadBalancerArn: awssdk.String(lbARN), }) @@ -98,9 +99,9 @@ func (m *defaultLoadBalancerManager) GetLoadBalancerAttributes(ctx context.Conte return resp.Attributes, nil } -func (m *defaultLoadBalancerManager) GetLoadBalancerResourceTags(ctx context.Context, resARN string) ([]*elbv2sdk.Tag, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerResourceTags(ctx context.Context, resARN string) ([]elbv2types.Tag, error) { resp, err := m.elbv2Client.DescribeTagsWithContext(ctx, &elbv2sdk.DescribeTagsInput{ - ResourceArns: awssdk.StringSlice([]string{resARN}), + ResourceArns: []string{resARN}, }) if err != nil { return nil, err @@ -108,7 +109,7 @@ func (m *defaultLoadBalancerManager) GetLoadBalancerResourceTags(ctx context.Con return resp.TagDescriptions[0].Tags, nil } -func (m *defaultLoadBalancerManager) GetLoadBalancerListenerRules(ctx context.Context, lsARN string) ([]*elbv2sdk.Rule, error) { +func (m *defaultLoadBalancerManager) GetLoadBalancerListenerRules(ctx context.Context, lsARN string) ([]elbv2types.Rule, error) { listenersRules, err := m.elbv2Client.DescribeRulesWithContext(ctx, &elbv2sdk.DescribeRulesInput{ ListenerArn: awssdk.String(lsARN), }) diff --git a/test/framework/resources/aws/target_group.go b/test/framework/resources/aws/target_group.go index da95095e79..d766aea023 100644 --- a/test/framework/resources/aws/target_group.go +++ b/test/framework/resources/aws/target_group.go @@ -2,18 +2,19 @@ package aws import ( "context" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "github.com/go-logr/logr" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" ) // TargetGroupManager is responsible for TargetGroup resources. type TargetGroupManager interface { - GetTargetGroupsForLoadBalancer(ctx context.Context, lbARN string) ([]*elbv2sdk.TargetGroup, error) + GetTargetGroupsForLoadBalancer(ctx context.Context, lbARN string) ([]elbv2types.TargetGroup, error) CheckTargetGroupHealthy(ctx context.Context, tgARN string, expectedTargetCount int) (bool, error) GetCurrentTargetCount(ctx context.Context, tgARN string) (int, error) - GetTargetGroupAttributes(ctx context.Context, tgARN string) ([]*elbv2sdk.TargetGroupAttribute, error) + GetTargetGroupAttributes(ctx context.Context, tgARN string) ([]elbv2types.TargetGroupAttribute, error) } // NewDefaultTargetGroupManager constructs new defaultTargetGroupManager. @@ -33,7 +34,7 @@ type defaultTargetGroupManager struct { } // GetTargetGroupsForLoadBalancer returns all targetgroups configured for the load balancer -func (m *defaultTargetGroupManager) GetTargetGroupsForLoadBalancer(ctx context.Context, lbARN string) ([]*elbv2sdk.TargetGroup, error) { +func (m *defaultTargetGroupManager) GetTargetGroupsForLoadBalancer(ctx context.Context, lbARN string) ([]elbv2types.TargetGroup, error) { targetGroups, err := m.elbv2Client.DescribeTargetGroupsWithContext(ctx, &elbv2sdk.DescribeTargetGroupsInput{ LoadBalancerArn: awssdk.String(lbARN), }) @@ -53,9 +54,9 @@ func (m *defaultTargetGroupManager) GetCurrentTargetCount(ctx context.Context, t } count := 0 for _, thd := range resp.TargetHealthDescriptions { - state := awssdk.StringValue(thd.TargetHealth.State) - if state == elbv2sdk.TargetHealthStateEnumHealthy || state == elbv2sdk.TargetHealthStateEnumInitial || - state == elbv2sdk.TargetHealthStateEnumUnhealthy { + state := string(thd.TargetHealth.State) + if elbv2types.TargetHealthStateEnum(state) == elbv2types.TargetHealthStateEnumHealthy || elbv2types.TargetHealthStateEnum(state) == elbv2types.TargetHealthStateEnumInitial || + elbv2types.TargetHealthStateEnum(state) == elbv2types.TargetHealthStateEnumUnhealthy { count++ } } @@ -63,7 +64,7 @@ func (m *defaultTargetGroupManager) GetCurrentTargetCount(ctx context.Context, t } // GetTargetGroupAttributes returns the targetgroup attributes for the given target group -func (m *defaultTargetGroupManager) GetTargetGroupAttributes(ctx context.Context, tgARN string) ([]*elbv2sdk.TargetGroupAttribute, error) { +func (m *defaultTargetGroupManager) GetTargetGroupAttributes(ctx context.Context, tgARN string) ([]elbv2types.TargetGroupAttribute, error) { resp, err := m.elbv2Client.DescribeTargetGroupAttributesWithContext(ctx, &elbv2sdk.DescribeTargetGroupAttributesInput{ TargetGroupArn: awssdk.String(tgARN), }) @@ -85,7 +86,7 @@ func (m *defaultTargetGroupManager) CheckTargetGroupHealthy(ctx context.Context, return false, nil } for _, thd := range resp.TargetHealthDescriptions { - if awssdk.StringValue(thd.TargetHealth.State) != elbv2sdk.TargetHealthStateEnumHealthy { + if thd.TargetHealth.State != elbv2types.TargetHealthStateEnumHealthy { return false, nil } } diff --git a/webhooks/elbv2/targetgroupbinding_mutator.go b/webhooks/elbv2/targetgroupbinding_mutator.go index 54fe7c40e3..8a005927cb 100644 --- a/webhooks/elbv2/targetgroupbinding_mutator.go +++ b/webhooks/elbv2/targetgroupbinding_mutator.go @@ -2,9 +2,10 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" @@ -65,9 +66,9 @@ func (m *targetGroupBindingMutator) defaultingTargetType(ctx context.Context, tg } var targetType elbv2api.TargetType switch sdkTargetType { - case elbv2sdk.TargetTypeEnumInstance: + case string(elbv2types.TargetTypeEnumInstance): targetType = elbv2api.TargetTypeInstance - case elbv2sdk.TargetTypeEnumIp: + case string(elbv2types.TargetTypeEnumIp): targetType = elbv2api.TargetTypeIP default: return errors.Errorf("unsupported TargetType: %v", sdkTargetType) @@ -106,7 +107,7 @@ func (m *targetGroupBindingMutator) obtainSDKTargetTypeFromAWS(ctx context.Conte if err != nil { return "", err } - return awssdk.StringValue(targetGroup.TargetType), nil + return string(targetGroup.TargetType), nil } // getTargetGroupIPAddressTypeFromAWS returns the target group IP address type of AWS target group @@ -116,20 +117,20 @@ func (m *targetGroupBindingMutator) getTargetGroupIPAddressTypeFromAWS(ctx conte return "", err } var ipAddressType elbv2api.TargetGroupIPAddressType - switch awssdk.StringValue(targetGroup.IpAddressType) { - case elbv2sdk.TargetGroupIpAddressTypeEnumIpv6: + switch string(targetGroup.IpAddressType) { + case string(elbv2types.TargetGroupIpAddressTypeEnumIpv6): ipAddressType = elbv2api.TargetGroupIPAddressTypeIPv6 - case elbv2sdk.TargetGroupIpAddressTypeEnumIpv4, "": + case string(elbv2types.TargetGroupIpAddressTypeEnumIpv4), "": ipAddressType = elbv2api.TargetGroupIPAddressTypeIPv4 default: - return "", errors.Errorf("unsupported IPAddressType: %v", awssdk.StringValue(targetGroup.IpAddressType)) + return "", errors.Errorf("unsupported IPAddressType: %v", string(targetGroup.IpAddressType)) } return ipAddressType, nil } -func (m *targetGroupBindingMutator) getTargetGroupFromAWS(ctx context.Context, tgARN string) (*elbv2sdk.TargetGroup, error) { +func (m *targetGroupBindingMutator) getTargetGroupFromAWS(ctx context.Context, tgARN string) (*elbv2types.TargetGroup, error) { req := &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{tgARN}), + TargetGroupArns: []string{tgARN}, } tgList, err := m.elbv2Client.DescribeTargetGroupsAsList(ctx, req) if err != nil { @@ -138,7 +139,7 @@ func (m *targetGroupBindingMutator) getTargetGroupFromAWS(ctx context.Context, t if len(tgList) != 1 { return nil, errors.Errorf("expecting a single targetGroup but got %v", len(tgList)) } - return tgList[0], nil + return &tgList[0], nil } func (m *targetGroupBindingMutator) getVpcIDFromAWS(ctx context.Context, tgARN string) (string, error) { @@ -146,7 +147,7 @@ func (m *targetGroupBindingMutator) getVpcIDFromAWS(ctx context.Context, tgARN s if err != nil { return "", err } - return awssdk.StringValue(targetGroup.VpcId), nil + return awssdk.ToString(targetGroup.VpcId), nil } // +kubebuilder:webhook:path=/mutate-elbv2-k8s-aws-v1beta1-targetgroupbinding,mutating=true,failurePolicy=fail,groups=elbv2.k8s.aws,resources=targetgroupbindings,verbs=create;update,versions=v1beta1,name=mtargetgroupbinding.elbv2.k8s.aws,sideEffects=None,webhookVersions=v1,admissionReviewVersions=v1beta1 diff --git a/webhooks/elbv2/targetgroupbinding_mutator_test.go b/webhooks/elbv2/targetgroupbinding_mutator_test.go index 65fe47c8b0..1b6df32614 100644 --- a/webhooks/elbv2/targetgroupbinding_mutator_test.go +++ b/webhooks/elbv2/targetgroupbinding_mutator_test.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors" @@ -18,7 +19,7 @@ import ( func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } @@ -70,12 +71,12 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnumInstance, }, }, }, @@ -103,12 +104,12 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), - TargetType: awssdk.String("ip"), + TargetType: elbv2types.TargetTypeEnumIp, }, }, }, @@ -136,12 +137,12 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-1"), - TargetType: awssdk.String("lambda"), + TargetType: elbv2types.TargetTypeEnumLambda, }, }, }, @@ -187,9 +188,9 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { VpcId: awssdk.String("vpcid-01"), }, @@ -221,7 +222,7 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, err: errors.New("vpcid not found"), }, @@ -266,7 +267,7 @@ func Test_targetGroupBindingMutator_MutateCreate(t *testing.T) { func Test_targetGroupBindingMutator_obtainSDKTargetTypeFromAWS(t *testing.T) { type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } @@ -289,11 +290,11 @@ func Test_targetGroupBindingMutator_obtainSDKTargetTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnumInstance, }, }, }, @@ -310,11 +311,11 @@ func Test_targetGroupBindingMutator_obtainSDKTargetTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { - TargetType: awssdk.String("ip"), + TargetType: elbv2types.TargetTypeEnumIp, }, }, }, @@ -331,7 +332,7 @@ func Test_targetGroupBindingMutator_obtainSDKTargetTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, err: errors.New("targetGroup not found"), }, @@ -370,7 +371,7 @@ func Test_targetGroupBindingMutator_obtainSDKTargetTypeFromAWS(t *testing.T) { func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } @@ -393,11 +394,11 @@ func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnumInstance, }, }, }, @@ -414,12 +415,12 @@ func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { - TargetType: awssdk.String("ip"), - IpAddressType: awssdk.String("ipv4"), + TargetType: elbv2types.TargetTypeEnumIp, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv4, }, }, }, @@ -436,12 +437,12 @@ func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { - TargetType: awssdk.String("ip"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumIp, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, }, }, }, @@ -458,7 +459,7 @@ func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, err: errors.New("targetGroup not found"), }, @@ -497,7 +498,7 @@ func Test_targetGroupBindingMutator_getIPAddressTypeFromAWS(t *testing.T) { func Test_targetGroupBindingMutator_obtainSDKVpcIDFromAWS(t *testing.T) { type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } @@ -520,9 +521,9 @@ func Test_targetGroupBindingMutator_obtainSDKVpcIDFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { VpcId: awssdk.String("vpcid-01"), }, @@ -541,7 +542,7 @@ func Test_targetGroupBindingMutator_obtainSDKVpcIDFromAWS(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-1"}), + TargetGroupArns: []string{"tg-1"}, }, err: errors.New("vpcid not found"), }, diff --git a/webhooks/elbv2/targetgroupbinding_validator.go b/webhooks/elbv2/targetgroupbinding_validator.go index 66583e687f..016ca002d2 100644 --- a/webhooks/elbv2/targetgroupbinding_validator.go +++ b/webhooks/elbv2/targetgroupbinding_validator.go @@ -2,11 +2,12 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "regexp" "strings" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/pkg/errors" "k8s.io/apimachinery/pkg/runtime" @@ -188,21 +189,21 @@ func (v *targetGroupBindingValidator) getTargetGroupIPAddressTypeFromAWS(ctx con return "", err } var ipAddressType elbv2api.TargetGroupIPAddressType - switch awssdk.StringValue(targetGroup.IpAddressType) { - case elbv2sdk.TargetGroupIpAddressTypeEnumIpv6: + switch string(targetGroup.IpAddressType) { + case string(elbv2types.TargetGroupIpAddressTypeEnumIpv6): ipAddressType = elbv2api.TargetGroupIPAddressTypeIPv6 - case elbv2sdk.TargetGroupIpAddressTypeEnumIpv4, "": + case string(elbv2types.TargetGroupIpAddressTypeEnumIpv4), "": ipAddressType = elbv2api.TargetGroupIPAddressTypeIPv4 default: - return "", errors.Errorf("unsupported IPAddressType: %v", awssdk.StringValue(targetGroup.IpAddressType)) + return "", errors.Errorf("unsupported IPAddressType: %v", string(targetGroup.IpAddressType)) } return ipAddressType, nil } // getTargetGroupFromAWS returns the AWS target group corresponding to the ARN -func (v *targetGroupBindingValidator) getTargetGroupFromAWS(ctx context.Context, tgARN string) (*elbv2sdk.TargetGroup, error) { +func (v *targetGroupBindingValidator) getTargetGroupFromAWS(ctx context.Context, tgARN string) (*elbv2types.TargetGroup, error) { req := &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{tgARN}), + TargetGroupArns: []string{tgARN}, } tgList, err := v.elbv2Client.DescribeTargetGroupsAsList(ctx, req) if err != nil { @@ -211,7 +212,7 @@ func (v *targetGroupBindingValidator) getTargetGroupFromAWS(ctx context.Context, if len(tgList) != 1 { return nil, errors.Errorf("expecting a single targetGroup but got %v", len(tgList)) } - return tgList[0], nil + return &tgList[0], nil } func (v *targetGroupBindingValidator) getVpcIDFromAWS(ctx context.Context, tgARN string) (string, error) { @@ -219,7 +220,7 @@ func (v *targetGroupBindingValidator) getVpcIDFromAWS(ctx context.Context, tgARN if err != nil { return "", err } - return awssdk.StringValue(targetGroup.VpcId), nil + return awssdk.ToString(targetGroup.VpcId), nil } // +kubebuilder:webhook:path=/validate-elbv2-k8s-aws-v1beta1-targetgroupbinding,mutating=false,failurePolicy=fail,groups=elbv2.k8s.aws,resources=targetgroupbindings,verbs=create;update,versions=v1beta1,name=vtargetgroupbinding.elbv2.k8s.aws,sideEffects=None,webhookVersions=v1,admissionReviewVersions=v1beta1 diff --git a/webhooks/elbv2/targetgroupbinding_validator_test.go b/webhooks/elbv2/targetgroupbinding_validator_test.go index e9ddf89e6e..3b329a44e1 100644 --- a/webhooks/elbv2/targetgroupbinding_validator_test.go +++ b/webhooks/elbv2/targetgroupbinding_validator_test.go @@ -2,10 +2,11 @@ package elbv2 import ( "context" + elbv2types "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2/types" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" - elbv2sdk "github.com/aws/aws-sdk-go/service/elbv2" + awssdk "github.com/aws/aws-sdk-go-v2/aws" + elbv2sdk "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "sigs.k8s.io/aws-load-balancer-controller/pkg/aws/services" @@ -27,7 +28,7 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { targetGroupIPAddressTypeIPv6 := elbv2api.TargetGroupIPAddressTypeIPv6 type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } @@ -64,12 +65,12 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnum("instance"), }, }, }, @@ -103,12 +104,12 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), + TargetType: elbv2types.TargetTypeEnumInstance, }, }, }, @@ -131,13 +132,13 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv4"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv4, }, }, }, @@ -160,13 +161,13 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, }, }, }, @@ -188,26 +189,26 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, VpcId: &clusterVpcID, }, }, }, { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, VpcId: &clusterVpcID, }, }, @@ -232,26 +233,26 @@ func Test_targetGroupBindingValidator_ValidateCreate(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, VpcId: &clusterVpcID, }, }, }, { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, - resp: []*elbv2sdk.TargetGroup{ + resp: []elbv2types.TargetGroup{ { TargetGroupArn: awssdk.String("tg-2"), - TargetType: awssdk.String("instance"), - IpAddressType: awssdk.String("ipv6"), + TargetType: elbv2types.TargetTypeEnumInstance, + IpAddressType: elbv2types.TargetGroupIpAddressTypeEnumIpv6, VpcId: &clusterVpcID, }, }, @@ -1081,7 +1082,7 @@ func Test_targetGroupBindingValidator_checkTargetGroupVpcID(t *testing.T) { } type describeTargetGroupsAsListCall struct { req *elbv2sdk.DescribeTargetGroupsInput - resp []*elbv2sdk.TargetGroup + resp []elbv2types.TargetGroup err error } type fields struct { @@ -1108,7 +1109,7 @@ func Test_targetGroupBindingValidator_checkTargetGroupVpcID(t *testing.T) { describeTargetGroupsAsListCalls: []describeTargetGroupsAsListCall{ { req: &elbv2sdk.DescribeTargetGroupsInput{ - TargetGroupArns: awssdk.StringSlice([]string{"tg-2"}), + TargetGroupArns: []string{"tg-2"}, }, err: errors.New("vpcid not found"), }, diff --git a/webhooks/networking/ingress_validator.go b/webhooks/networking/ingress_validator.go index f0c441267f..acb71c3fd1 100644 --- a/webhooks/networking/ingress_validator.go +++ b/webhooks/networking/ingress_validator.go @@ -4,7 +4,7 @@ import ( "context" "fmt" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/pkg/errors" networking "k8s.io/api/networking/v1" @@ -178,11 +178,11 @@ func (v *ingressValidator) checkIngressClassUsage(ctx context.Context, ing *netw if ing.Spec.IngressClassName != nil { usedInNewIng = true - newIngressClassName = awssdk.StringValue(ing.Spec.IngressClassName) + newIngressClassName = awssdk.ToString(ing.Spec.IngressClassName) } if oldIng != nil && oldIng.Spec.IngressClassName != nil { usedInOldIng = true - oldIngressClassName = awssdk.StringValue(oldIng.Spec.IngressClassName) + oldIngressClassName = awssdk.ToString(oldIng.Spec.IngressClassName) } if usedInNewIng { diff --git a/webhooks/networking/ingress_validator_test.go b/webhooks/networking/ingress_validator_test.go index 4ae5658463..a902c93263 100644 --- a/webhooks/networking/ingress_validator_test.go +++ b/webhooks/networking/ingress_validator_test.go @@ -4,7 +4,7 @@ import ( "context" "testing" - awssdk "github.com/aws/aws-sdk-go/aws" + awssdk "github.com/aws/aws-sdk-go-v2/aws" "github.com/go-logr/logr" "github.com/golang/mock/gomock" "github.com/pkg/errors"