Repository: jpignata/fargate Branch: master Commit: aa1c09cd404e Files: 118 Total size: 1.8 MB Directory structure: gitextract_6knv8f8q/ ├── .circleci/ │ └── config.yml ├── .dockerignore ├── .gitignore ├── CHANGELOG.md ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── Dockerfile ├── LICENSE ├── Makefile ├── README.md ├── acm/ │ ├── certificate.go │ ├── certificate_test.go │ ├── main.go │ └── mock/ │ ├── client/ │ │ └── client.go │ └── sdk/ │ ├── acmiface.go │ └── paginators.go ├── cloudwatchlogs/ │ ├── log_group.go │ └── main.go ├── cmd/ │ ├── certificate.go │ ├── certificate_destroy.go │ ├── certificate_destroy_test.go │ ├── certificate_import.go │ ├── certificate_import_test.go │ ├── certificate_info.go │ ├── certificate_info_test.go │ ├── certificate_list.go │ ├── certificate_list_test.go │ ├── certificate_request.go │ ├── certificate_request_test.go │ ├── certificate_test.go │ ├── certificate_validate.go │ ├── certificate_validate_test.go │ ├── lb.go │ ├── lb_alias.go │ ├── lb_alias_test.go │ ├── lb_create.go │ ├── lb_create_test.go │ ├── lb_destroy.go │ ├── lb_info.go │ ├── lb_list.go │ ├── lb_list_test.go │ ├── logs.go │ ├── mock/ │ │ └── output.go │ ├── output.go │ ├── output_test.go │ ├── port.go │ ├── port_test.go │ ├── root.go │ ├── root_test.go │ ├── service.go │ ├── service_create.go │ ├── service_deploy.go │ ├── service_destroy.go │ ├── service_env.go │ ├── service_env_list.go │ ├── service_env_set.go │ ├── service_env_unset.go │ ├── service_info.go │ ├── service_list.go │ ├── service_logs.go │ ├── service_ps.go │ ├── service_restart.go │ ├── service_scale.go │ ├── service_update.go │ ├── string_util.go │ ├── string_util_test.go │ ├── task.go │ ├── task_info.go │ ├── task_list.go │ ├── task_logs.go │ ├── task_ps.go │ ├── task_run.go │ ├── task_stop.go │ ├── testdata/ │ │ ├── certificate.crt │ │ ├── chain.crt │ │ └── private.key │ ├── vpc_operation.go │ └── vpc_operation_test.go ├── console/ │ └── main.go ├── doc/ │ └── website/ │ ├── index.html │ └── styles.css ├── docker/ │ └── main.go ├── ec2/ │ ├── eni.go │ ├── main.go │ ├── mock/ │ │ ├── client/ │ │ │ └── client.go │ │ └── sdk/ │ │ └── ec2iface.go │ ├── vpc.go │ └── vpc_test.go ├── ecr/ │ ├── main.go │ └── repository.go ├── ecs/ │ ├── cluster.go │ ├── main.go │ ├── service.go │ ├── task.go │ └── task_definition.go ├── elbv2/ │ ├── listener.go │ ├── listener_test.go │ ├── load_balancer.go │ ├── load_balancer_test.go │ ├── main.go │ ├── mock/ │ │ ├── client/ │ │ │ └── client.go │ │ └── sdk/ │ │ ├── elbv2iface.go │ │ └── paginators.go │ ├── target_group.go │ └── target_group_test.go ├── git/ │ ├── main.go │ └── main_test.go ├── go.mod ├── go.sum ├── iam/ │ ├── main.go │ └── role.go ├── main.go └── route53/ ├── hosted_zone.go ├── hosted_zone_test.go ├── main.go └── mock/ ├── client/ │ └── client.go └── sdk/ ├── paginators.go └── route53iface.go ================================================ FILE CONTENTS ================================================ ================================================ FILE: .circleci/config.yml ================================================ version: 2 jobs: build: docker: - image: circleci/golang:1.10 working_directory: /go/src/github.com/awslabs/fargatecli steps: - checkout - run: git config --global user.email circleci@pignata.com - run: git config --global user.name CircleCI - run: go get -u github.com/golang/dep/cmd/dep - run: dep ensure - run: make test ================================================ FILE: .dockerignore ================================================ Dockerfile ================================================ FILE: .gitignore ================================================ .DS_Store bin fargate dist fargatecli vendor ================================================ FILE: CHANGELOG.md ================================================ ## 0.3.1 (2019-05-09) ### Enhancements - Added support for ap-south-1, ca-central-1 and ap-northeast-2 regions ## 0.3.0 (2019-03-14) ### Enhancements - Console output reworked for consistency and brevity - macOS users get emoji as a type prefix in console output :tada: -- disable with --no-emoji if you're not into fun - Requests and responses from AWS are displayed in full when --verbose is passed - Added additional AWS Fargate regions - Added --task-command flag to allow overriding of the Docker command used by the container - If you have a region set in your AWS credentials, use that by default and only fall back to us-east-1 if no region is set - Added --assign-public-ip boolean flag, which allows you to control whether a task has a public IP address (default: true) ### Bug Fixes - Environment variable service commands now return a polite error message when invoked without the service name. ([#22][issue-22]) - Certificate import command re-implemented to work correctly. Previously calls to this command always returned "private key not supported" as we were incorrectly encoding it to base64 before passing it to the AWS SDK. ### Chores - Utilize `dep` for dependency management - Add contributor guide, updated license to repo ## 0.2.3 (2018-01-19) ### Features - Support **--task-role** flag in service create and task run to allow passing a role name for the tasks to assume. ([#8][issue-8]) ### Enhancements - Use the `ForceNewDeployment` feature of `UpdateService` in service restart instead of incrementing the task definition. ([#14][issue-14]) ### Bug Fixes - Fixed issue where we'd stomp on an existing task role on service updates like deployments or environment variable changes. ([#8][issue-8]) ## 0.2.2 (2018-01-11) ### Bug Fixes - Fix service update operation to properly validate and run. ([#11][issue-11]) - Bail out early in service info if the requested service is not active meaning it has been previously destroyed. ## 0.2.1 (2018-01-02) ### Bug Fixes - service create will not run if a load balancer is configured without a port. - service create and task run will no longer create a repository if an image is explictly passed. - service destroy will remove all references the service's target group and delete it. - Fix git repo detection to properly use a git sha image tag rather than a time stamp tag. ([#6][issue-6]) - Fail fast if a user attempts to destroy a service scaled above 0. ## 0.2.0 (2017-12-31) ### Features - Added **--cluster** global flag to allow running commands against other clusters rather than the default. If omitted, the default **fargate** cluster is used. ([#2][issue-2]) - lb create, service create, and task run now accept an optional **--subnet-id** flag to place resources in different VPCs and subnets rather than the defaults. If omitted, resources will be placed within the default subnets within the default VPC. ([#2][issue-2]) - lb create, service create, and task run now accept an optional **--security-group-id** flag to allow applying more restrictive security groups to load balancers, services, and tasks. This flag can be passed multiple times to apply multiple security groups. If omitted, a permissive security group will be applied. ### Bug Fixes - Resolved crashes with certificates missing resource records. Certificates that fail to be issued immediately after request would cause crashes in lb info and lb list as the resource record was never generated. [issue-2]: https://github.com/awslabs/fargatecli/issues/2 [issue-6]: https://github.com/awslabs/fargatecli/issues/6 [issue-8]: https://github.com/awslabs/fargatecli/issues/8 [issue-11]: https://github.com/awslabs/fargatecli/issues/11 [issue-14]: https://github.com/awslabs/fargatecli/issues/14 [issue-22]: https://github.com/awslabs/fargatecli/issues/22 ================================================ FILE: CODE_OF_CONDUCT.md ================================================ # Amazon Open Source Code of Conduct This code of conduct provides guidance on participation in Amazon-managed open source communities, and outlines the process for reporting unacceptable behavior. As an organization and community, we are committed to providing an inclusive environment for everyone. Anyone violating this code of conduct may be removed and banned from the community. **Our open source communities endeavor to:** - Use welcoming and inclusive language; - Be respectful of differing viewpoints at all times; - Accept constructive criticism and work together toward decisions; - Focus on what is best for the community and users. **Our Responsibility.** As contributors, members, or bystanders we each individually have the responsibility to behave professionally and respectfully at all times. Disrespectful and unacceptable behaviors include, but are not limited to: The use of violent threats, abusive, discriminatory, or derogatory language; - Offensive comments related to gender, gender identity and expression, sexual orientation, disability, mental illness, race, political or religious affiliation; - Posting of sexually explicit or violent content; - The use of sexualized language and unwelcome sexual attention or advances; - Public or private [harassment](http://todogroup.org/opencodeofconduct/#definitions) of any kind; - Publishing private information, such as physical or electronic address, without permission; - Other conduct which could reasonably be considered inappropriate in a professional setting; - Advocating for or encouraging any of the above behaviors. **Enforcement and Reporting Code of Conduct Issues.** Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting opensource-codeofconduct@amazon.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. **Attribution.** _This code of conduct is based on the [template](http://todogroup.org/opencodeofconduct) established by the [TODO Group](http://todogroup.org/) and the Scope section from the [Contributor Covenant version 1.4](http://contributor-covenant.org/version/1/4/)._ ================================================ FILE: CONTRIBUTING.md ================================================ **Welcome!** Thank you for considering contributing to this project! If I can help in anyway to get you going, please feel free to reach out. I'm available by email and Google Hangouts at john@pignata.com. # Contributing ## Workflow - **Did you find a bug?** Awesome! Please feel free to open an issue first, or if you have a fix open a pull request that describes the bug with code that demonstrates the bug in a test and addresses it. - **Do you want to add a feature?** Features begin life as a proposal. Please open a pull request with a proposal that explains the feature, its use case, considerations, and design. This will allow interested contributors to weigh in, refine the idea, and ensure there's no wasted time in the event a feature doesn't fit with our direction. ## Setup - Ensure you're using golang 1.9+. ```console go version ``` - Install [`dep`][dep] if not present on your system. See their [installation instructions][dep-install] and [releases page][dep-releases] for details. - Install the source code from GitHub ```console go get github.com/awslabs/fargatecli ``` - Run `dep ensure` to install required dependencies ```console cd $GOPATH/src/github.com/awslabs/fargatecli dep ensure ``` - Make sure you can run the tests ```console make test ``` ## Testing - Tests can be run via `go test` or `make test` - To generate mocks as you add functionality, run `make mocks` or use `go generate` directly ## Building - To build a binary for your platform run `make` - For cross-building for all supported platforms, run `make dist` which builds binaries for darwin (64-bit) and linux (Arm, 32-bit, 64-bit). ## Licensing This project is released under the [Apache 2.0 license][apache]. ## Code of Conduct This project abides by the [Amazon Open Source Code of Conduct][amzn-coc]. Please be nice. [dep]: https://golang.github.io/dep [dep-install]: https://golang.github.io/dep/docs/installation.html [dep-releases]: https://github.com/golang/dep/releases [amzn-coc]: https://aws.github.io/code-of-conduct [apache]: http://aws.amazon.com/apache-2-0/ ================================================ FILE: Dockerfile ================================================ FROM golang:alpine RUN apk add --no-cache git upx WORKDIR /fargate ADD go.mod . RUN go mod download ADD . /fargate RUN go build -ldflags="-s -w" RUN upx --brute fargate FROM alpine RUN apk add --no-cache ca-certificates COPY --from=0 /fargate/fargate /usr/local/bin/ ================================================ FILE: LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: Makefile ================================================ .PHONY: mocks test build dist PACKAGES := $(shell go list ./... | grep -v /mock) mocks: go get github.com/golang/mock/mockgen go generate $(PACKAGES) test: go test -race -cover $(PACKAGES) build: go build -o bin/fargate main.go dist: GOOS=darwin GOARCH=amd64 go build -o dist/build/fargate-darwin-amd64/fargate main.go GOOS=linux GOARCH=amd64 go build -o dist/build/fargate-linux-amd64/fargate main.go GOOS=linux GOARCH=386 go build -o dist/build/fargate-linux-386/fargate main.go GOOS=linux GOARCH=arm go build -o dist/build/fargate-linux-arm/fargate main.go GOOS=windows go get -u github.com/spf13/cobra GOOS=windows GOARCH=amd64 go build -o dist/build/fargate-windows-amd64/fargate.exe main.go GOOS=windows GOARCH=386 go build -o dist/build/fargate-windows-386/fargate.exe main.go cd dist/build/fargate-darwin-amd64 && zip fargate-${FARGATE_VERSION}-darwin-amd64.zip fargate cd dist/build/fargate-linux-amd64 && zip fargate-${FARGATE_VERSION}-linux-amd64.zip fargate cd dist/build/fargate-linux-386 && zip fargate-${FARGATE_VERSION}-linux-386.zip fargate cd dist/build/fargate-linux-arm && zip fargate-${FARGATE_VERSION}-linux-arm.zip fargate cd dist/build/fargate-windows-amd64 && zip fargate-${FARGATE_VERSION}-windows-amd64.zip fargate.exe cd dist/build/fargate-windows-386 && zip fargate-${FARGATE_VERSION}-windows-386.zip fargate.exe find dist/build -name *.zip -exec mv {} dist \; rm -rf dist/build ================================================ FILE: README.md ================================================ # Fargate CLI [![CircleCI](https://circleci.com/gh/jpignata/fargate/tree/master.svg?style=svg)](https://circleci.com/gh/jpignata/fargate/tree/master) [![GoDoc](https://godoc.org/github.com/awslabs/fargatecli?status.svg)](https://godoc.org/github.com/awslabs/fargatecli) # NOTICE :exclamation: :exclamation: :exclamation: Please note that this project is no longer actively maintained. A better option for new Fargate deployments on AWS is [the AWS Copilot CLI](https://github.com/aws/copilot-cli), which is both more featureful, and actively maintained by AWS. :exclamation: :exclamation: :exclamation: ## Screencast [![fargate CLI screencast](http://img.youtube.com/vi/P6iY6ovhbfc/0.jpg)](http://www.youtube.com/watch?v=P6iY6ovhbfc) ## Usage ### Configuration #### Region By default, fargate uses *us-east-1*. The CLI accepts a --region parameter and will honor *AWS_REGION* and *AWS_DEFAULT_REGION* environment settings. Note that specifying a region where all required services aren't available will return an error. See the [Region Table][region-table] for a breakdown of what services are available in which regions. #### Credentials fargate is built using the [AWS SDK for Go][go-sdk] which looks for credentials in the following locations: 1. [Environment Variables][go-env-vars] 1. [Shared Credentials File][go-shared-credentials-file] 1. [EC2 Instance Profile][go-iam-roles-for-ec2-instances] For more information see [Specifying Credentials][go-specifying-credentials] in the AWS SDK for Go documentation. ### Commands - [Tasks](#tasks) - [Services](#services) - [Load Balancers](#load-balancers) - [Certificates](#certificates) #### Global Flags | Flag | Default | Description | | --- | --- | --- | | --cluster | fargate | ECS cluster name | | --region | us-east-1 | AWS region | | --no-color | false | Disable color output | | --verbose | false | Verbose output | #### Tasks Tasks are one-time executions of your container. Instances of your task are run until you manually stop them either through AWS APIs, the AWS Management Console, or `fargate task stop`, or until they are interrupted for any reason. - [list](#fargate-task-list) - [run](#fargate-task-run) - [info](#fargate-task-info) - [ps](#fargate-task-ps) - [logs](#fargate-task-logs) - [stop](#fargate-task-stop) ##### fargate task list ```console fargate task list ``` List running task groups ##### fargate task run ```console fargate task run [--num ] [--cpu ] [--memory ] [--image ] [--env ] [--task-role ] [--subnet-id ] [--security-group-id ] ``` Run new tasks You must specify a task group name in order to interact with the task(s) in subsequent commands to view logs, stop and inspect tasks. Task group names do not have to be unique -- multiple configurations of task instances can be started with the same task group. Multiple instances of a task can be run by specifying a number in the --num flag. If no number is specified, a single task instance will be run. CPU and memory settings can be optionally specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | If not specified, fargate will launch minimally sized tasks at 0.25 vCPU (256 CPU units) and 0.5GB (512 MiB) of memory. The Docker container image to use in the task can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used. Environment variables can be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables. Security groups can optionally be specified for the task by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the task. By default, the task will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. A task role can be optionally specified via the --task-role flag by providing eith a full IAM role ARN or the name of an IAM role. The tasks will be able to assume this role. ##### fargate task info ```console fargate task info [--task ] ``` Inspect tasks Shows extended information for each running task within a task group or for specific tasks specified with the --task flag. Information includes environment variables which could differ between tasks in a task group. To inspect multiple specific tasks within a task group specific --task with a task ID multiple times. ##### fargate task ps ```console fargate task ps ``` List running tasks ##### fargate task logs ```console fargate task logs [--follow] [--start ] [--end ] [--filter ] [--task ] ``` Show logs from tasks Return either a specific segment of task logs or tail logs in real-time using the --follow option. Logs are prefixed by their log stream name which is in the format of "fargate/\/\." Follow will continue to run and return logs until interrupted by Control-C. If --follow is passed --end cannot be specified. Logs can be returned for specific tasks within a task group by passing a task ID via the --task flag. Pass --task with a task ID multiple times in order to retrieve logs from multiple specific tasks. A specific window of logs can be requested by passing --start and --end options with a time expression. The time expression can be either a duration or a timestamp: - Duration (e.g. -1h [one hour ago], -1h10m30s [one hour, ten minutes, and thirty seconds ago], 2h [two hours from now]) - Timestamp with optional timezone in the format of YYYY-MM-DD HH:MM:SS [TZ]; timezone will default to UTC if omitted (e.g. 2017-12-22 15:10:03 EST) You can filter logs for specific term by passing a filter expression via the --filter flag. Pass a single term to search for that term, pass multiple terms to search for log messages that include all terms. See the [CloudWatch Logs documentation][cwl-filter-expression] for more details. ##### fargate task stop ```console fargate task stop [--task ] ``` Stop tasks Stops all tasks within a task group if run with only a task group name or stops individual tasks if one or more tasks are passed via the --task flag. Specify --task with a task ID parameter multiple times to stop multiple specific tasks. #### Services Services manage long-lived instances of your containers that are run on AWS Fargate. If your container exits for any reason, the service scheduler will restart your containers and ensure your service has the desired number of tasks running. Services can be used in concert with a load balancer to distribute traffic amongst the tasks in your service. - [list](#fargate-service-list) - [create](#fargate-service-create) - [deploy](#fargate-service-deploy) - [info](#fargate-service-info) - [logs](#fargate-service-logs) - [ps](#fargate-service-ps) - [scale](#fargate-service-scale) - [env set](#fargate-service-env-set) - [env unset](#fargate-service-env-unset) - [env list](#fargate-service-env-list) - [update](#fargate-service-update) - [restart](#fargate-service-restart) - [destroy](#fargate-service-destroy) ##### fargate service list ```console fargate service list ``` List services ##### fargate service create ```console fargate service create [--cpu ] [--memory ] [--port ] [--lb ] [--rule ] [--image ] [--env ] [--num ] [--task-role ] [--subnet-id ] [--security-group-id ] ``` Create a new service CPU and memory settings can be optionally specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | If not specified, fargate will launch minimally sized tasks at 0.25 vCPU (256 CPU units) and 0.5GB (512 MiB) of memory. The Docker container image to use in the service can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used. To use the service with a load balancer, a port must be specified when the service is created. Specify a port by passing the --port flag and a port expression of protocol:port-number. For example, if the service listens on port 80 and uses HTTP, specify HTTP:80. Valid protocols are HTTP, HTTPS, and TCP. You can only specify a single port. Services can optionally be configured to use a load balancer. To put a load balancer in front a service, pass the --lb flag with the name of a load balancer. If you specify a load balancer, you must also specify a port via the --port flag to which the load balancer should forward requests. Optionally, Application Load Balancers can be configured to route HTTP/HTTPS traffic to the service based upon a rule. Rules are configured by passing one or more rules by specifying the --rule flag along with a rule expression. Rule expressions are in the format of TYPE=VALUE. Type can either be PATH or HOST. PATH matches the PATH of the request and HOST matches the requested hostname in the HTTP request. Both PATH and HOST types can include up to three wildcard characters: \* to match multiple characters and ? to match a single character. If rules are omitted, the service will be the load balancer's default action. Environment variables can be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables. Specify the desired count of tasks the service should maintain by passing the --num flag with a number. If you omit this flag, fargate will configure a service with a desired number of tasks of 1. Security groups can optionally be specified for the service by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the service. By default, the service will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. A task role can be optionally specified via the --task-role flag by providing eith a full IAM role ARN or the name of an IAM role. The tasks run by the service will be able to assume this role. ##### fargate service deploy ```console fargate service deploy [--image ] ``` Deploy new image to service The Docker container image to use in the service can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used. ##### fargate service info ```console fargate service info ``` Inspect service Show extended information for a service including load balancer configuration, active deployments, and environment variables. Deployments show active versions of your service that are running. Multiple deployments are shown if a service is transitioning due to a deployment or update to configuration such a CPU, memory, or environment variables. ##### fargate service logs ```console fargate service logs [--follow] [--start ] [--end ] [--filter ] [--task ] ``` Show logs from tasks in a service Return either a specific segment of service logs or tail logs in real-time using the --follow option. Logs are prefixed by their log stream name which is in the format of "fargate/\/\." Follow will continue to run and return logs until interrupted by Control-C. If --follow is passed --end cannot be specified. Logs can be returned for specific tasks within a service by passing a task ID via the --task flag. Pass --task with a task ID multiple times in order to retrieve logs from multiple specific tasks. A specific window of logs can be requested by passing --start and --end options with a time expression. The time expression can be either a duration or a timestamp: - Duration (e.g. -1h [one hour ago], -1h10m30s [one hour, ten minutes, and thirty seconds ago], 2h [two hours from now]) - Timestamp with optional timezone in the format of YYYY-MM-DD HH:MM:SS [TZ]; timezone will default to UTC if omitted (e.g. 2017-12-22 15:10:03 EST) You can filter logs for specific term by passing a filter expression via the --filter flag. Pass a single term to search for that term, pass multiple terms to search for log messages that include all terms. See the [CloudWatch Logs documentation][cwl-filter-expression] for more details. ##### fargate service ps ```console fargate service ps ``` List running tasks for a service ##### fargate service scale ```console fargate service scale ``` Scale number of tasks in a service Changes the number of desired tasks to be run in a service by the given scale expression. A scale expression can either be an absolute number or a delta specified with a sign such as +5 or -2. ##### fargate service env set ```console fargate service env set --env ``` Set environment variables At least one environment variable must be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables. ##### fargate service env unset ```console fargate service env unset --key ``` Unset environment variables Unsets the environment variable specified via the --key flag. Specify --key with a key name multiple times to unset multiple variables. ##### fargate service env list ```console fargate service env list ``` Show environment variables ##### fargate service update ```console fargate service update [--cpu ] [--memory ] ``` Update service configuration CPU and memory settings are specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | At least one of --cpu or --memory must be specified. ##### fargate service restart ```console fargate service restart ``` Restart service Creates a new set of tasks for the service and stops the previous tasks. This is useful if your service needs to reload data cached from an external source, for example. ##### fargate service destroy ```console fargate service destroy ``` Destroy service In order to destroy a service, it must first be scaled to 0 running tasks. #### Load Balancers Load balancers distribute incoming traffic between the tasks within a service for HTTP/HTTPS and TCP applications. HTTP/HTTPS load balancers can route to multiple services based upon rules you specify when you create a new service. - [list](#fargate-lb-list) - [create](#fargate-lb-create) - [destroy](#fargate-lb-destroy) - [alias](#fargate-lb-alias) - [info](#fargate-lb-info) ##### fargate lb list ```console fargate lb list ``` List load balancers ##### fargate lb create ```console fargate lb create --port [--certificate ] [--subnet-id ] [--security-group-id ] [--scheme ] ``` Create a load balancer At least one port must be specified for the load balancer listener via the --port flag and a port expression of protocol:port-number. For example, if you wanted an HTTP load balancer to listen on port 80, you would specify HTTP:80. Valid protocols are HTTP, HTTPS, and TCP. You can specify multiple listeners by passing the --port flag with a port expression multiple times. You cannot mix TCP ports with HTTP/HTTPS ports on a single load balancer. You can optionally include certificates to secure HTTPS ports by passed the --certificate flag along with a certificate name. This option can be specified multiple times to add additional certificates to a single load balancer which uses Service Name Identification (SNI) to select the appropriate certificate for the request. By default, the load balancer will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. HTTP/HTTPS load balancers require at least two subnets attached while a TCP load balancer requires only one. You may only specify a single subnet from each availability zone. Security groups can optionally be specified for HTTP/HTTPS load balancers by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the load balancer. You can also choose the scheme type for load balancer via the --scheme flag. By default, load balancers are internet-facing. ##### fargate lb destroy ```console fargate lb destroy ``` Destroy load balancer ##### fargate lb alias ```console fargate lb alias ``` Create a load balancer alias record Create an alias record to the load balancer for domains that are hosted within Amazon Route 53 and within the same AWS account. If you're using another DNS provider or host your domains in a different account, you will need to manually create this record. ##### fargate lb info ```console fargate lb info ``` Inspect load balancer Returns extended information about a load balancer including a list of listeners, rules, and certificates in use by the load balancer. #### Certificates Certificates are TLS certificates issued by or imported into AWS Certificate Manager for use in securing traffic between load balancers and end users. ACM provides TLS certificates free of charge for use within AWS resources. - [list](#fargate-certificate-list) - [import](#fargate-certificate-import) - [request](#fargate-certificate-request) - [info](#fargate-certificate-info) - [validate](#fargate-certificate-validate) - [destroy](#fargate-certificate-destroy) ##### fargate certificate list ```console fargate certificate list ``` List certificates ##### fargate certificate import ```console fargate certificate import --certificate --key [--chain ] ``` Import a certificate Upload a certificate from a certificate file, a private key file, and optionally an intermediate certificate chain file. The files must be PEM-encoded and the private key must not be encrypted or protected by a passphrase. See the [AWS Certificate Manager documentation][acm-import-cert] for more details. ##### fargate certificate request ```console fargate certificate request [--alias ] ``` Request a certificate Certificates can be for a fully qualified domain name (e.g. www.example.com) or a wildcard domain name (e.g. *.example.com). You can add aliases to a certificate by specifying additional domain names via the --alias flag. To add multiple aliases, pass --alias multiple times. By default, AWS Certificate Manager has a limit of 10 domain names per certificate, but this limit can be raised by AWS support. ##### fargate certificate info ```console fargate certificate info ``` Inspect certificate Show extended information for a certificate. Includes each validation for the certificate which shows DNS records which must be created to validate domain ownership. ##### fargate certificate validate ```console fargate certificate validate ``` Validate certificate ownership fargate will automatically create DNS validation record to verify ownership for any domain names that are hosted within Amazon Route 53. If your certificate has aliases, a validation record will be attempted per alias. Any records whose domains are hosted in other DNS hosting providers or in other DNS accounts and cannot be automatically validated will have the necessary records output. These records are also available in `fargate certificate info \`. AWS Certificate Manager may take up to several hours after the DNS records are created to complete validation and issue the certificate. ##### fargate certificate destroy ```console fargate certificate destroy ``` Destroy certificate In order to destroy a certificate, it must not be in use by any load balancers or any other AWS resources. [region-table]: https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/ [go-sdk]: https://aws.amazon.com/documentation/sdk-for-go/ [go-env-vars]: http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#environment-variables [go-shared-credentials-file]: http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#shared-credentials-file [go-iam-roles-for-ec2-instances]: http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#iam-roles-for-ec2-instances [go-specifying-credentials]: http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials [cwl-filter-expression]: http://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/FilterAndPatternSyntax.html#matching-terms-events [acm-import-cert]: http://docs.aws.amazon.com/acm/latest/APIReference/API_ImportCertificate.html ================================================ FILE: acm/certificate.go ================================================ package acm import ( "fmt" "strings" "github.com/aws/aws-sdk-go/aws" awsacm "github.com/aws/aws-sdk-go/service/acm" ) // Certificate is a certificate hosted in AWS Certificate Manager. type Certificate struct { ARN string Status string SubjectAlternativeNames []string DomainName string Validations []CertificateValidation Type string } // AddValidation adds a certificate validation to a certificate. func (c *Certificate) AddValidation(v CertificateValidation) { c.Validations = append(c.Validations, v) } // IsIssued returns true if the certificate's status is ISSUED. func (c Certificate) IsIssued() bool { return c.Status == awsacm.CertificateStatusIssued } // IsPendingValidation returns true if the certificate's status is PENDING_VALIDATION. func (c Certificate) IsPendingValidation() bool { return c.Status == awsacm.CertificateStatusPendingValidation } // CertificateValidation holds details about how to validate a certificate. type CertificateValidation struct { Status string DomainName string ResourceRecord CertificateResourceRecord } // IsFailed returns true if a certificate validation's status is FAILED. func (v CertificateValidation) IsFailed() bool { return v.Status == awsacm.DomainStatusFailed } // IsPendingValidation returns true if a certificate validation's status is PENDING_VALIDATION. func (v CertificateValidation) IsPendingValidation() bool { return v.Status == awsacm.DomainStatusPendingValidation } // IsSuccess returns true if a certificate validation's status is SUCCESS func (v CertificateValidation) IsSuccess() bool { return v.Status == awsacm.DomainStatusSuccess } // ResourceRecordString returns the resource record for display. func (v CertificateValidation) ResourceRecordString() string { if v.ResourceRecord.Type == "" { return "" } return fmt.Sprintf("%s %s -> %s", v.ResourceRecord.Type, v.ResourceRecord.Name, v.ResourceRecord.Value, ) } // CertificateResourceRecord contains the DNS record used to validate a certificate. type CertificateResourceRecord struct { Type string Name string Value string } // Certificates is a collection of certificates. type Certificates []Certificate // GetCertificates returns certificates for the given domain name. func (cs Certificates) GetCertificates(domainName string) Certificates { var certificates Certificates for _, c := range cs { if c.DomainName == domainName { certificates = append(certificates, c) } } return certificates } // ValidateAlias checks an alias' length and number of octets for validity. func ValidateAlias(alias string) error { if len(alias) < 1 || len(alias) > 253 { return fmt.Errorf("%s: An alias must be between 1 and 253 characters in length", alias) } if strings.Count(alias, ".") > 252 { return fmt.Errorf("%s: An alias cannot exceed 253 octets", alias) } if strings.Count(alias, ".") == 0 { return fmt.Errorf("%s: An alias requires at least 2 octets", alias) } return nil } // ValidateDomainName checks a domain names length and number of octets for validity. func ValidateDomainName(domainName string) error { if len(domainName) < 1 || len(domainName) > 253 { return fmt.Errorf("%s: The domain name must be between 1 and 253 characters in length", domainName) } if strings.Count(domainName, ".") > 62 { return fmt.Errorf("%s: The domain name cannot exceed 63 octets", domainName) } if strings.Count(domainName, ".") == 0 { return fmt.Errorf("%s: The domain name requires at least 2 octets", domainName) } return nil } // DeleteCertificate deletes the certificate identified by the given ARN. func (acm SDKClient) DeleteCertificate(arn string) error { input := &awsacm.DeleteCertificateInput{ CertificateArn: aws.String(arn), } if _, err := acm.client.DeleteCertificate(input); err != nil { return err } return nil } // ImportCertificate creates a new certificate from the provided certificate, private key, and // optional certificate chain. func (acm SDKClient) ImportCertificate(certificate, privateKey, certificateChain []byte) (string, error) { input := &awsacm.ImportCertificateInput{ Certificate: certificate, PrivateKey: privateKey, } if len(certificateChain) != 0 { input.SetCertificateChain(certificateChain) } resp, err := acm.client.ImportCertificate(input) if err != nil { return "", err } return aws.StringValue(resp.CertificateArn), nil } // InflateCertificate uses a partially hydrated certificate to fetch the rest of its details and // set them on the certificate. func (acm SDKClient) InflateCertificate(c *Certificate) error { resp, err := acm.client.DescribeCertificate( &awsacm.DescribeCertificateInput{ CertificateArn: aws.String(c.ARN), }, ) if err != nil { return err } c.Status = aws.StringValue(resp.Certificate.Status) c.SubjectAlternativeNames = aws.StringValueSlice(resp.Certificate.SubjectAlternativeNames) c.Type = aws.StringValue(resp.Certificate.Type) for _, domainValidation := range resp.Certificate.DomainValidationOptions { validation := CertificateValidation{ Status: aws.StringValue(domainValidation.ValidationStatus), DomainName: aws.StringValue(domainValidation.DomainName), } if domainValidation.ResourceRecord != nil { validation.ResourceRecord = CertificateResourceRecord{ Type: aws.StringValue(domainValidation.ResourceRecord.Type), Name: aws.StringValue(domainValidation.ResourceRecord.Name), Value: aws.StringValue(domainValidation.ResourceRecord.Value), } } c.AddValidation(validation) } return nil } // ListCertificates returns all certificates associated with the caller's account. func (acm SDKClient) ListCertificates() (Certificates, error) { var certificates Certificates input := &awsacm.ListCertificatesInput{} handler := func(resp *awsacm.ListCertificatesOutput, lastPage bool) bool { for _, cs := range resp.CertificateSummaryList { c := Certificate{ ARN: aws.StringValue(cs.CertificateArn), DomainName: aws.StringValue(cs.DomainName), } certificates = append(certificates, c) } return true } err := acm.client.ListCertificatesPages(input, handler) return certificates, err } // RequestCertificate creates a new certificate. func (acm SDKClient) RequestCertificate(domainName string, aliases []string) (string, error) { requestCertificateInput := &awsacm.RequestCertificateInput{ DomainName: aws.String(domainName), ValidationMethod: aws.String(awsacm.ValidationMethodDns), } if len(aliases) > 0 { requestCertificateInput.SetSubjectAlternativeNames(aws.StringSlice(aliases)) } resp, err := acm.client.RequestCertificate(requestCertificateInput) if err != nil { return "", err } return aws.StringValue(resp.CertificateArn), nil } // ListCertificateDomainNames is bunk and will be refactored out of existence soon. func (acm *SDKClient) ListCertificateDomainNames(certificateARNs []string) []string { var domainNames []string certificates, _ := acm.ListCertificates() for _, certificate := range certificates { for _, certificateARN := range certificateARNs { if certificate.ARN == certificateARN { domainNames = append(domainNames, certificate.DomainName) } } } return domainNames } ================================================ FILE: acm/certificate_test.go ================================================ package acm import ( "errors" "fmt" "math/rand" "reflect" "strings" "testing" "github.com/aws/aws-sdk-go/aws" awsacm "github.com/aws/aws-sdk-go/service/acm" "github.com/awslabs/fargatecli/acm/mock/sdk" "github.com/golang/mock/gomock" ) func TestValidateAlias(t *testing.T) { var tests = []struct { in string out error }{ {"valid.example.com", nil}, {"invalid", errors.New("An alias requires at least 2 octets")}, {strings.Repeat(".", 253), errors.New("An alias cannot exceed 253 octets")}, {strings.Repeat("a", 255), errors.New("An alias must be between 1 and 253 characters in length")}, {"", errors.New("An alias must be between 1 and 253 characters in length")}, } for _, test := range tests { err := ValidateAlias(test.in) switch { case test.out == nil: if err != nil { t.Errorf("Expected nil, got %s", err) } default: if !strings.Contains(err.Error(), test.out.Error()) { t.Errorf("Expected contains %s, got %s", test.out.Error(), err.Error()) } } } } func TestValidateDomainName(t *testing.T) { var tests = []struct { in string out error }{ {"valid.example.com", nil}, {"invalid", errors.New("The domain name requires at least 2 octets")}, {strings.Repeat(".", 63), errors.New("The domain name cannot exceed 63 octets")}, {strings.Repeat("a", 255), errors.New("The domain name must be between 1 and 253 characters in length")}, {"", errors.New("The domain name must be between 1 and 253 characters in length")}, } for _, test := range tests { err := ValidateDomainName(test.in) switch { case test.out == nil: if err != nil { t.Errorf("Expected nil, got %s", err) } default: if !strings.Contains(err.Error(), test.out.Error()) { t.Errorf("Expected contains %s, got %s", test.out.Error(), err.Error()) } } } } func TestCertificateIsPendingValidation(t *testing.T) { var tests = []struct { in Certificate out bool }{ {Certificate{Status: "PENDING_VALIDATION"}, true}, {Certificate{Status: "ISSUED"}, false}, {Certificate{Status: ""}, false}, } for _, test := range tests { if test.in.IsPendingValidation() != test.out { t.Errorf("Expected %s to be IsPendingValidation", test.in.Status) } } } func TestCertificateIsIssued(t *testing.T) { var tests = []struct { in Certificate out bool }{ {Certificate{Status: "ISSUED"}, true}, {Certificate{Status: "PENDING_VALIDATION"}, false}, {Certificate{Status: ""}, false}, } for _, test := range tests { if test.in.IsIssued() != test.out { t.Errorf("Expected %s to be IsIssued", test.in.Status) } } } func TestCertificateValidationIsPendingValidation(t *testing.T) { var tests = []struct { in CertificateValidation out bool }{ {CertificateValidation{Status: "PENDING_VALIDATION"}, true}, {CertificateValidation{Status: "SUCCESS"}, false}, {CertificateValidation{Status: ""}, false}, } for _, test := range tests { if test.in.IsPendingValidation() != test.out { t.Errorf("Expected %s to be IsPendingValidation", test.in.Status) } } } func TestCertificateValidationIsSuccess(t *testing.T) { var tests = []struct { in CertificateValidation out bool }{ {CertificateValidation{Status: "SUCCESS"}, true}, {CertificateValidation{Status: "PENDING_VALIDATION"}, false}, {CertificateValidation{Status: ""}, false}, } for _, test := range tests { if test.in.IsSuccess() != test.out { t.Errorf("Expected %s to be IsSuccess", test.in.Status) } } } func TestCertificateValidationIsFailed(t *testing.T) { var tests = []struct { in CertificateValidation out bool }{ {CertificateValidation{Status: "FAILED"}, true}, {CertificateValidation{Status: "PENDING_VALIDATION"}, false}, {CertificateValidation{Status: ""}, false}, } for _, test := range tests { if test.in.IsFailed() != test.out { t.Errorf("Expected %s to be IsFailed", test.in.Status) } } } func TestCertificateValidationResourceRecordString(t *testing.T) { var tests = []struct { in CertificateValidation out string }{ {CertificateValidation{}, ""}, {CertificateValidation{ ResourceRecord: CertificateResourceRecord{ Type: "CNAME", Name: "name", Value: "value", }, }, "CNAME name -> value"}, } for _, test := range tests { if test.in.ResourceRecordString() != test.out { t.Errorf("Expected ResourceRecordString() == CNAME name -> value, got: %s", test.in.ResourceRecordString()) } } } func TestCertificatesGetCertificates(t *testing.T) { certificates := Certificates{ Certificate{DomainName: "staging.example.com", ARN: "staging.example.com-1"}, Certificate{DomainName: "www.example.com", ARN: "www.example.com-1"}, Certificate{DomainName: "www.example.com", ARN: "www.example.com-2"}, } var empty Certificates var tests = []struct { in string out Certificates }{ {"staging.example.com", Certificates{certificates[0]}}, {"www.example.com", Certificates{certificates[1], certificates[2]}}, {"www.amazon.com", empty}, } for _, test := range tests { if !reflect.DeepEqual(certificates.GetCertificates(test.in), test.out) { t.Errorf("Expected %+v, got: %+v", test.out, certificates.GetCertificates(test.in)) } } } func TestRequestCertificate(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" domainName := "*.example.com" aliases := []string{"example-other.com"} validationMethod := "DNS" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.RequestCertificateInput{ DomainName: aws.String(domainName), ValidationMethod: aws.String(validationMethod), SubjectAlternativeNames: aws.StringSlice(aliases), } o := &awsacm.RequestCertificateOutput{ CertificateArn: aws.String(certificateARN), } mockACMAPI.EXPECT().RequestCertificate(i).Return(o, nil) arn, err := acm.RequestCertificate(domainName, aliases) if err != nil { t.Errorf("Error; %+v", err) } if arn != certificateARN { t.Errorf("Invalid certificate ARN; want: %s, got: %s", certificateARN, arn) } } func TestRequestCertificateError(t *testing.T) { var aliases []string domainName := "*.example.com" validationMethod := "DNS" // Simulating a certificate request with more than 10 domains for i := 0; i < 10; i++ { aliases = append(aliases, fmt.Sprintf("example-%d.com", i)) } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.RequestCertificateInput{ DomainName: aws.String(domainName), ValidationMethod: aws.String(validationMethod), SubjectAlternativeNames: aws.StringSlice(aliases), } o := &awsacm.RequestCertificateOutput{} mockACMAPI.EXPECT().RequestCertificate(i).Return(o, errors.New("certificate has too many domains")) arn, err := acm.RequestCertificate(domainName, aliases) if err == nil { t.Errorf("No error; want: %+v", err) } if arn != "" { t.Errorf("Invalid certificate ARN; want: empty, got: %s", arn) } } func TestListCertificates(t *testing.T) { resp := &awsacm.ListCertificatesOutput{ CertificateSummaryList: []*awsacm.CertificateSummary{ &awsacm.CertificateSummary{ DomainName: aws.String("www.example.com"), CertificateArn: aws.String("arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012"), }, }, } mockClient := sdk.MockListCertificatesPagesClient{Resp: resp} acm := SDKClient{client: mockClient} certificates, err := acm.ListCertificates() if err != nil { t.Errorf("Expected no error, got %+v", err) } if len(certificates) != 1 { t.Errorf("Expected 1 certificate, got %d", len(certificates)) } if certificates[0].DomainName != "www.example.com" { t.Errorf("Expected certificate domain to be www.example.com, got %s", certificates[0].DomainName) } } func TestListCertificatesError(t *testing.T) { mockClient := sdk.MockListCertificatesPagesClient{ Resp: &awsacm.ListCertificatesOutput{}, Error: errors.New(":-("), } acm := SDKClient{client: mockClient} certificates, err := acm.ListCertificates() if err == nil { t.Errorf("Expected error, got nil") } if len(certificates) > 0 { t.Errorf("Expected no certificates, got %d", len(certificates)) } } func TestDeleteCertificate(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.DeleteCertificateInput{CertificateArn: aws.String(certificateARN)} o := &awsacm.DeleteCertificateOutput{} mockACMAPI.EXPECT().DeleteCertificate(i).Return(o, nil) err := acm.DeleteCertificate(certificateARN) if err != nil { t.Errorf("Error; %+v", err) } } func TestDeleteCertificateError(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.DeleteCertificateInput{CertificateArn: aws.String(certificateARN)} o := &awsacm.DeleteCertificateOutput{} mockACMAPI.EXPECT().DeleteCertificate(i).Return(o, errors.New(":-(")) err := acm.DeleteCertificate(certificateARN) if err == nil { t.Error("Expected error, got nil") } } func TestInflateCertificate(t *testing.T) { domainName := "www.example.com" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificateType := "AMAZON_ISSUED" certificateStatus := "PENDING_VALIDATION" certificateSANs := []string{"staging.example.com"} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.DescribeCertificateInput{ CertificateArn: aws.String(certificateARN), } o := &awsacm.DescribeCertificateOutput{ Certificate: &awsacm.CertificateDetail{ Type: aws.String(certificateType), Status: aws.String(certificateStatus), SubjectAlternativeNames: aws.StringSlice(certificateSANs), DomainValidationOptions: []*awsacm.DomainValidation{ &awsacm.DomainValidation{ ValidationStatus: aws.String("SUCCESS"), DomainName: aws.String("staging.example.com"), ResourceRecord: &awsacm.ResourceRecord{ Name: aws.String("_beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com"), Type: aws.String("CNAME"), Value: aws.String("_6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws."), }, }, &awsacm.DomainValidation{ ValidationStatus: aws.String("PENDING_VALIDATION"), DomainName: aws.String(domainName), ResourceRecord: &awsacm.ResourceRecord{ Name: aws.String("_beeed67ae3f2d83f6cd3e19a8064947b.www.example.com"), Type: aws.String("CNAME"), Value: aws.String("_6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws."), }, }, }, }, } certificate := Certificate{ DomainName: domainName, ARN: certificateARN, } mockACMAPI.EXPECT().DescribeCertificate(i).Return(o, nil) if err := acm.InflateCertificate(&certificate); err != nil { t.Errorf("Expected no error, got %+v", err) } if certificate.DomainName != domainName { t.Errorf("Expected DomainName %s, got %s", domainName, certificate.DomainName) } if certificate.ARN != certificateARN { t.Errorf("Expected ARN %s, got %s", certificateARN, certificate.ARN) } if certificate.Type != certificateType { t.Errorf("Expected type %s, got %s", certificateType, certificate.Type) } if certificate.Status != certificateStatus { t.Errorf("Expected status %s, got %s", certificateStatus, certificate.Status) } if !reflect.DeepEqual(certificateSANs, certificate.SubjectAlternativeNames) { t.Errorf("Expected subject alternative names %v, got %v", certificateSANs, certificate.SubjectAlternativeNames) } if len(certificate.Validations) != 2 { t.Errorf("Expected 2 validations, got %d", len(certificate.Validations)) } } func TestInflateCertificateError(t *testing.T) { certificate := Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "www.example.com", } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.DescribeCertificateInput{CertificateArn: aws.String(certificate.ARN)} o := &awsacm.DescribeCertificateOutput{} mockACMAPI.EXPECT().DescribeCertificate(i).Return(o, errors.New(":-(")) err := acm.InflateCertificate(&certificate) if err == nil { t.Error("Expected error, got nil") } } func TestImportCertificate(t *testing.T) { dummy := make([]byte, 10) rand.Read(dummy) certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.ImportCertificateInput{ Certificate: dummy, CertificateChain: dummy, PrivateKey: dummy, } o := &awsacm.ImportCertificateOutput{ CertificateArn: aws.String(certificateARN), } mockACMAPI.EXPECT().ImportCertificate(i).Return(o, nil) arn, err := acm.ImportCertificate(dummy, dummy, dummy) if err != nil { t.Errorf("Expected no error, got %s", err) } if arn != certificateARN { t.Errorf("Expected ARN == %s, got: %s", certificateARN, arn) } } func TestImportCertificateError(t *testing.T) { var empty []byte mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockACMAPI := sdk.NewMockACMAPI(mockCtrl) acm := SDKClient{client: mockACMAPI} i := &awsacm.ImportCertificateInput{ Certificate: empty, CertificateChain: empty, PrivateKey: empty, } o := &awsacm.ImportCertificateOutput{} mockACMAPI.EXPECT().ImportCertificate(i).Return(o, errors.New(":-(")) _, err := acm.ImportCertificate(empty, empty, empty) if err == nil { t.Error("Expected error, got nil") } } ================================================ FILE: acm/main.go ================================================ package acm //go:generate mockgen -package client -destination=mock/client/client.go github.com/awslabs/fargatecli/acm Client //go:generate mockgen -package sdk -source ../vendor/github.com/aws/aws-sdk-go/service/acm/acmiface/interface.go -destination=mock/sdk/acmiface.go github.com/aws/aws-sdk-go/service/acm/acmiface ACMAPI import ( "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" ) // Client represents a method for accessing AWS Certificate Manager. type Client interface { DeleteCertificate(string) error InflateCertificate(*Certificate) error ListCertificates() (Certificates, error) RequestCertificate(string, []string) (string, error) ImportCertificate([]byte, []byte, []byte) (string, error) } // SDKClient implements access to AWS Certificate Manager via the AWS SDK. type SDKClient struct { client acmiface.ACMAPI } // New returns an SDKClient configured with the given session. func New(sess *session.Session) SDKClient { return SDKClient{ client: acm.New(sess), } } ================================================ FILE: acm/mock/client/client.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/awslabs/fargatecli/acm (interfaces: Client) // Package client is a generated GoMock package. package client import ( acm "github.com/awslabs/fargatecli/acm" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } // MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } // NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } // DeleteCertificate mocks base method func (m *MockClient) DeleteCertificate(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteCertificate", arg0) ret0, _ := ret[0].(error) return ret0 } // DeleteCertificate indicates an expected call of DeleteCertificate func (mr *MockClientMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockClient)(nil).DeleteCertificate), arg0) } // ImportCertificate mocks base method func (m *MockClient) ImportCertificate(arg0, arg1, arg2 []byte) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ImportCertificate", arg0, arg1, arg2) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // ImportCertificate indicates an expected call of ImportCertificate func (mr *MockClientMockRecorder) ImportCertificate(arg0, arg1, arg2 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificate", reflect.TypeOf((*MockClient)(nil).ImportCertificate), arg0, arg1, arg2) } // InflateCertificate mocks base method func (m *MockClient) InflateCertificate(arg0 *acm.Certificate) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "InflateCertificate", arg0) ret0, _ := ret[0].(error) return ret0 } // InflateCertificate indicates an expected call of InflateCertificate func (mr *MockClientMockRecorder) InflateCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InflateCertificate", reflect.TypeOf((*MockClient)(nil).InflateCertificate), arg0) } // ListCertificates mocks base method func (m *MockClient) ListCertificates() (acm.Certificates, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListCertificates") ret0, _ := ret[0].(acm.Certificates) ret1, _ := ret[1].(error) return ret0, ret1 } // ListCertificates indicates an expected call of ListCertificates func (mr *MockClientMockRecorder) ListCertificates() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificates", reflect.TypeOf((*MockClient)(nil).ListCertificates)) } // RequestCertificate mocks base method func (m *MockClient) RequestCertificate(arg0 string, arg1 []string) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RequestCertificate", arg0, arg1) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // RequestCertificate indicates an expected call of RequestCertificate func (mr *MockClientMockRecorder) RequestCertificate(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificate", reflect.TypeOf((*MockClient)(nil).RequestCertificate), arg0, arg1) } ================================================ FILE: acm/mock/sdk/acmiface.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: ../vendor/github.com/aws/aws-sdk-go/service/acm/acmiface/interface.go // Package sdk is a generated GoMock package. package sdk import ( aws "github.com/aws/aws-sdk-go/aws" request "github.com/aws/aws-sdk-go/aws/request" acm "github.com/aws/aws-sdk-go/service/acm" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockACMAPI is a mock of ACMAPI interface type MockACMAPI struct { ctrl *gomock.Controller recorder *MockACMAPIMockRecorder } // MockACMAPIMockRecorder is the mock recorder for MockACMAPI type MockACMAPIMockRecorder struct { mock *MockACMAPI } // NewMockACMAPI creates a new mock instance func NewMockACMAPI(ctrl *gomock.Controller) *MockACMAPI { mock := &MockACMAPI{ctrl: ctrl} mock.recorder = &MockACMAPIMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockACMAPI) EXPECT() *MockACMAPIMockRecorder { return m.recorder } // AddTagsToCertificate mocks base method func (m *MockACMAPI) AddTagsToCertificate(arg0 *acm.AddTagsToCertificateInput) (*acm.AddTagsToCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddTagsToCertificate", arg0) ret0, _ := ret[0].(*acm.AddTagsToCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AddTagsToCertificate indicates an expected call of AddTagsToCertificate func (mr *MockACMAPIMockRecorder) AddTagsToCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificate", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificate), arg0) } // AddTagsToCertificateWithContext mocks base method func (m *MockACMAPI) AddTagsToCertificateWithContext(arg0 aws.Context, arg1 *acm.AddTagsToCertificateInput, arg2 ...request.Option) (*acm.AddTagsToCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AddTagsToCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.AddTagsToCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AddTagsToCertificateWithContext indicates an expected call of AddTagsToCertificateWithContext func (mr *MockACMAPIMockRecorder) AddTagsToCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificateWithContext), varargs...) } // AddTagsToCertificateRequest mocks base method func (m *MockACMAPI) AddTagsToCertificateRequest(arg0 *acm.AddTagsToCertificateInput) (*request.Request, *acm.AddTagsToCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AddTagsToCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.AddTagsToCertificateOutput) return ret0, ret1 } // AddTagsToCertificateRequest indicates an expected call of AddTagsToCertificateRequest func (mr *MockACMAPIMockRecorder) AddTagsToCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsToCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).AddTagsToCertificateRequest), arg0) } // DeleteCertificate mocks base method func (m *MockACMAPI) DeleteCertificate(arg0 *acm.DeleteCertificateInput) (*acm.DeleteCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteCertificate", arg0) ret0, _ := ret[0].(*acm.DeleteCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteCertificate indicates an expected call of DeleteCertificate func (mr *MockACMAPIMockRecorder) DeleteCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificate", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificate), arg0) } // DeleteCertificateWithContext mocks base method func (m *MockACMAPI) DeleteCertificateWithContext(arg0 aws.Context, arg1 *acm.DeleteCertificateInput, arg2 ...request.Option) (*acm.DeleteCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.DeleteCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteCertificateWithContext indicates an expected call of DeleteCertificateWithContext func (mr *MockACMAPIMockRecorder) DeleteCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificateWithContext), varargs...) } // DeleteCertificateRequest mocks base method func (m *MockACMAPI) DeleteCertificateRequest(arg0 *acm.DeleteCertificateInput) (*request.Request, *acm.DeleteCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.DeleteCertificateOutput) return ret0, ret1 } // DeleteCertificateRequest indicates an expected call of DeleteCertificateRequest func (mr *MockACMAPIMockRecorder) DeleteCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).DeleteCertificateRequest), arg0) } // DescribeCertificate mocks base method func (m *MockACMAPI) DescribeCertificate(arg0 *acm.DescribeCertificateInput) (*acm.DescribeCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeCertificate", arg0) ret0, _ := ret[0].(*acm.DescribeCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeCertificate indicates an expected call of DescribeCertificate func (mr *MockACMAPIMockRecorder) DescribeCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificate", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificate), arg0) } // DescribeCertificateWithContext mocks base method func (m *MockACMAPI) DescribeCertificateWithContext(arg0 aws.Context, arg1 *acm.DescribeCertificateInput, arg2 ...request.Option) (*acm.DescribeCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.DescribeCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeCertificateWithContext indicates an expected call of DescribeCertificateWithContext func (mr *MockACMAPIMockRecorder) DescribeCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificateWithContext), varargs...) } // DescribeCertificateRequest mocks base method func (m *MockACMAPI) DescribeCertificateRequest(arg0 *acm.DescribeCertificateInput) (*request.Request, *acm.DescribeCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.DescribeCertificateOutput) return ret0, ret1 } // DescribeCertificateRequest indicates an expected call of DescribeCertificateRequest func (mr *MockACMAPIMockRecorder) DescribeCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).DescribeCertificateRequest), arg0) } // ExportCertificate mocks base method func (m *MockACMAPI) ExportCertificate(arg0 *acm.ExportCertificateInput) (*acm.ExportCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ExportCertificate", arg0) ret0, _ := ret[0].(*acm.ExportCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ExportCertificate indicates an expected call of ExportCertificate func (mr *MockACMAPIMockRecorder) ExportCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificate", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificate), arg0) } // ExportCertificateWithContext mocks base method func (m *MockACMAPI) ExportCertificateWithContext(arg0 aws.Context, arg1 *acm.ExportCertificateInput, arg2 ...request.Option) (*acm.ExportCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ExportCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.ExportCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ExportCertificateWithContext indicates an expected call of ExportCertificateWithContext func (mr *MockACMAPIMockRecorder) ExportCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificateWithContext), varargs...) } // ExportCertificateRequest mocks base method func (m *MockACMAPI) ExportCertificateRequest(arg0 *acm.ExportCertificateInput) (*request.Request, *acm.ExportCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ExportCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.ExportCertificateOutput) return ret0, ret1 } // ExportCertificateRequest indicates an expected call of ExportCertificateRequest func (mr *MockACMAPIMockRecorder) ExportCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ExportCertificateRequest), arg0) } // GetCertificate mocks base method func (m *MockACMAPI) GetCertificate(arg0 *acm.GetCertificateInput) (*acm.GetCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCertificate", arg0) ret0, _ := ret[0].(*acm.GetCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCertificate indicates an expected call of GetCertificate func (mr *MockACMAPIMockRecorder) GetCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificate", reflect.TypeOf((*MockACMAPI)(nil).GetCertificate), arg0) } // GetCertificateWithContext mocks base method func (m *MockACMAPI) GetCertificateWithContext(arg0 aws.Context, arg1 *acm.GetCertificateInput, arg2 ...request.Option) (*acm.GetCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.GetCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCertificateWithContext indicates an expected call of GetCertificateWithContext func (mr *MockACMAPIMockRecorder) GetCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).GetCertificateWithContext), varargs...) } // GetCertificateRequest mocks base method func (m *MockACMAPI) GetCertificateRequest(arg0 *acm.GetCertificateInput) (*request.Request, *acm.GetCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.GetCertificateOutput) return ret0, ret1 } // GetCertificateRequest indicates an expected call of GetCertificateRequest func (mr *MockACMAPIMockRecorder) GetCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).GetCertificateRequest), arg0) } // ImportCertificate mocks base method func (m *MockACMAPI) ImportCertificate(arg0 *acm.ImportCertificateInput) (*acm.ImportCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ImportCertificate", arg0) ret0, _ := ret[0].(*acm.ImportCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ImportCertificate indicates an expected call of ImportCertificate func (mr *MockACMAPIMockRecorder) ImportCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificate", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificate), arg0) } // ImportCertificateWithContext mocks base method func (m *MockACMAPI) ImportCertificateWithContext(arg0 aws.Context, arg1 *acm.ImportCertificateInput, arg2 ...request.Option) (*acm.ImportCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ImportCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.ImportCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ImportCertificateWithContext indicates an expected call of ImportCertificateWithContext func (mr *MockACMAPIMockRecorder) ImportCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificateWithContext), varargs...) } // ImportCertificateRequest mocks base method func (m *MockACMAPI) ImportCertificateRequest(arg0 *acm.ImportCertificateInput) (*request.Request, *acm.ImportCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ImportCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.ImportCertificateOutput) return ret0, ret1 } // ImportCertificateRequest indicates an expected call of ImportCertificateRequest func (mr *MockACMAPIMockRecorder) ImportCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ImportCertificateRequest), arg0) } // ListCertificates mocks base method func (m *MockACMAPI) ListCertificates(arg0 *acm.ListCertificatesInput) (*acm.ListCertificatesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListCertificates", arg0) ret0, _ := ret[0].(*acm.ListCertificatesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListCertificates indicates an expected call of ListCertificates func (mr *MockACMAPIMockRecorder) ListCertificates(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificates", reflect.TypeOf((*MockACMAPI)(nil).ListCertificates), arg0) } // ListCertificatesWithContext mocks base method func (m *MockACMAPI) ListCertificatesWithContext(arg0 aws.Context, arg1 *acm.ListCertificatesInput, arg2 ...request.Option) (*acm.ListCertificatesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListCertificatesWithContext", varargs...) ret0, _ := ret[0].(*acm.ListCertificatesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListCertificatesWithContext indicates an expected call of ListCertificatesWithContext func (mr *MockACMAPIMockRecorder) ListCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesWithContext), varargs...) } // ListCertificatesRequest mocks base method func (m *MockACMAPI) ListCertificatesRequest(arg0 *acm.ListCertificatesInput) (*request.Request, *acm.ListCertificatesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListCertificatesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.ListCertificatesOutput) return ret0, ret1 } // ListCertificatesRequest indicates an expected call of ListCertificatesRequest func (mr *MockACMAPIMockRecorder) ListCertificatesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesRequest", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesRequest), arg0) } // ListCertificatesPages mocks base method func (m *MockACMAPI) ListCertificatesPages(arg0 *acm.ListCertificatesInput, arg1 func(*acm.ListCertificatesOutput, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListCertificatesPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ListCertificatesPages indicates an expected call of ListCertificatesPages func (mr *MockACMAPIMockRecorder) ListCertificatesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCertificatesPages", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesPages), arg0, arg1) } // ListCertificatesPagesWithContext mocks base method func (m *MockACMAPI) ListCertificatesPagesWithContext(arg0 aws.Context, arg1 *acm.ListCertificatesInput, arg2 func(*acm.ListCertificatesOutput, 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, "ListCertificatesPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ListCertificatesPagesWithContext indicates an expected call of ListCertificatesPagesWithContext func (mr *MockACMAPIMockRecorder) ListCertificatesPagesWithContext(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, "ListCertificatesPagesWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListCertificatesPagesWithContext), varargs...) } // ListTagsForCertificate mocks base method func (m *MockACMAPI) ListTagsForCertificate(arg0 *acm.ListTagsForCertificateInput) (*acm.ListTagsForCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForCertificate", arg0) ret0, _ := ret[0].(*acm.ListTagsForCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForCertificate indicates an expected call of ListTagsForCertificate func (mr *MockACMAPIMockRecorder) ListTagsForCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificate", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificate), arg0) } // ListTagsForCertificateWithContext mocks base method func (m *MockACMAPI) ListTagsForCertificateWithContext(arg0 aws.Context, arg1 *acm.ListTagsForCertificateInput, arg2 ...request.Option) (*acm.ListTagsForCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTagsForCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.ListTagsForCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForCertificateWithContext indicates an expected call of ListTagsForCertificateWithContext func (mr *MockACMAPIMockRecorder) ListTagsForCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificateWithContext), varargs...) } // ListTagsForCertificateRequest mocks base method func (m *MockACMAPI) ListTagsForCertificateRequest(arg0 *acm.ListTagsForCertificateInput) (*request.Request, *acm.ListTagsForCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.ListTagsForCertificateOutput) return ret0, ret1 } // ListTagsForCertificateRequest indicates an expected call of ListTagsForCertificateRequest func (mr *MockACMAPIMockRecorder) ListTagsForCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).ListTagsForCertificateRequest), arg0) } // RemoveTagsFromCertificate mocks base method func (m *MockACMAPI) RemoveTagsFromCertificate(arg0 *acm.RemoveTagsFromCertificateInput) (*acm.RemoveTagsFromCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTagsFromCertificate", arg0) ret0, _ := ret[0].(*acm.RemoveTagsFromCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RemoveTagsFromCertificate indicates an expected call of RemoveTagsFromCertificate func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificate", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificate), arg0) } // RemoveTagsFromCertificateWithContext mocks base method func (m *MockACMAPI) RemoveTagsFromCertificateWithContext(arg0 aws.Context, arg1 *acm.RemoveTagsFromCertificateInput, arg2 ...request.Option) (*acm.RemoveTagsFromCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RemoveTagsFromCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.RemoveTagsFromCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RemoveTagsFromCertificateWithContext indicates an expected call of RemoveTagsFromCertificateWithContext func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificateWithContext), varargs...) } // RemoveTagsFromCertificateRequest mocks base method func (m *MockACMAPI) RemoveTagsFromCertificateRequest(arg0 *acm.RemoveTagsFromCertificateInput) (*request.Request, *acm.RemoveTagsFromCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RemoveTagsFromCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.RemoveTagsFromCertificateOutput) return ret0, ret1 } // RemoveTagsFromCertificateRequest indicates an expected call of RemoveTagsFromCertificateRequest func (mr *MockACMAPIMockRecorder) RemoveTagsFromCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsFromCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RemoveTagsFromCertificateRequest), arg0) } // RenewCertificate mocks base method func (m *MockACMAPI) RenewCertificate(arg0 *acm.RenewCertificateInput) (*acm.RenewCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RenewCertificate", arg0) ret0, _ := ret[0].(*acm.RenewCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RenewCertificate indicates an expected call of RenewCertificate func (mr *MockACMAPIMockRecorder) RenewCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificate", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificate), arg0) } // RenewCertificateWithContext mocks base method func (m *MockACMAPI) RenewCertificateWithContext(arg0 aws.Context, arg1 *acm.RenewCertificateInput, arg2 ...request.Option) (*acm.RenewCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RenewCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.RenewCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RenewCertificateWithContext indicates an expected call of RenewCertificateWithContext func (mr *MockACMAPIMockRecorder) RenewCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificateWithContext), varargs...) } // RenewCertificateRequest mocks base method func (m *MockACMAPI) RenewCertificateRequest(arg0 *acm.RenewCertificateInput) (*request.Request, *acm.RenewCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RenewCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.RenewCertificateOutput) return ret0, ret1 } // RenewCertificateRequest indicates an expected call of RenewCertificateRequest func (mr *MockACMAPIMockRecorder) RenewCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RenewCertificateRequest), arg0) } // RequestCertificate mocks base method func (m *MockACMAPI) RequestCertificate(arg0 *acm.RequestCertificateInput) (*acm.RequestCertificateOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RequestCertificate", arg0) ret0, _ := ret[0].(*acm.RequestCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RequestCertificate indicates an expected call of RequestCertificate func (mr *MockACMAPIMockRecorder) RequestCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificate", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificate), arg0) } // RequestCertificateWithContext mocks base method func (m *MockACMAPI) RequestCertificateWithContext(arg0 aws.Context, arg1 *acm.RequestCertificateInput, arg2 ...request.Option) (*acm.RequestCertificateOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "RequestCertificateWithContext", varargs...) ret0, _ := ret[0].(*acm.RequestCertificateOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // RequestCertificateWithContext indicates an expected call of RequestCertificateWithContext func (mr *MockACMAPIMockRecorder) RequestCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificateWithContext", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificateWithContext), varargs...) } // RequestCertificateRequest mocks base method func (m *MockACMAPI) RequestCertificateRequest(arg0 *acm.RequestCertificateInput) (*request.Request, *acm.RequestCertificateOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "RequestCertificateRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.RequestCertificateOutput) return ret0, ret1 } // RequestCertificateRequest indicates an expected call of RequestCertificateRequest func (mr *MockACMAPIMockRecorder) RequestCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestCertificateRequest", reflect.TypeOf((*MockACMAPI)(nil).RequestCertificateRequest), arg0) } // ResendValidationEmail mocks base method func (m *MockACMAPI) ResendValidationEmail(arg0 *acm.ResendValidationEmailInput) (*acm.ResendValidationEmailOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResendValidationEmail", arg0) ret0, _ := ret[0].(*acm.ResendValidationEmailOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ResendValidationEmail indicates an expected call of ResendValidationEmail func (mr *MockACMAPIMockRecorder) ResendValidationEmail(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmail", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmail), arg0) } // ResendValidationEmailWithContext mocks base method func (m *MockACMAPI) ResendValidationEmailWithContext(arg0 aws.Context, arg1 *acm.ResendValidationEmailInput, arg2 ...request.Option) (*acm.ResendValidationEmailOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ResendValidationEmailWithContext", varargs...) ret0, _ := ret[0].(*acm.ResendValidationEmailOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ResendValidationEmailWithContext indicates an expected call of ResendValidationEmailWithContext func (mr *MockACMAPIMockRecorder) ResendValidationEmailWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmailWithContext", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmailWithContext), varargs...) } // ResendValidationEmailRequest mocks base method func (m *MockACMAPI) ResendValidationEmailRequest(arg0 *acm.ResendValidationEmailInput) (*request.Request, *acm.ResendValidationEmailOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ResendValidationEmailRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.ResendValidationEmailOutput) return ret0, ret1 } // ResendValidationEmailRequest indicates an expected call of ResendValidationEmailRequest func (mr *MockACMAPIMockRecorder) ResendValidationEmailRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendValidationEmailRequest", reflect.TypeOf((*MockACMAPI)(nil).ResendValidationEmailRequest), arg0) } // UpdateCertificateOptions mocks base method func (m *MockACMAPI) UpdateCertificateOptions(arg0 *acm.UpdateCertificateOptionsInput) (*acm.UpdateCertificateOptionsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateCertificateOptions", arg0) ret0, _ := ret[0].(*acm.UpdateCertificateOptionsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateCertificateOptions indicates an expected call of UpdateCertificateOptions func (mr *MockACMAPIMockRecorder) UpdateCertificateOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificateOptions", reflect.TypeOf((*MockACMAPI)(nil).UpdateCertificateOptions), arg0) } // UpdateCertificateOptionsWithContext mocks base method func (m *MockACMAPI) UpdateCertificateOptionsWithContext(arg0 aws.Context, arg1 *acm.UpdateCertificateOptionsInput, arg2 ...request.Option) (*acm.UpdateCertificateOptionsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateCertificateOptionsWithContext", varargs...) ret0, _ := ret[0].(*acm.UpdateCertificateOptionsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateCertificateOptionsWithContext indicates an expected call of UpdateCertificateOptionsWithContext func (mr *MockACMAPIMockRecorder) UpdateCertificateOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificateOptionsWithContext", reflect.TypeOf((*MockACMAPI)(nil).UpdateCertificateOptionsWithContext), varargs...) } // UpdateCertificateOptionsRequest mocks base method func (m *MockACMAPI) UpdateCertificateOptionsRequest(arg0 *acm.UpdateCertificateOptionsInput) (*request.Request, *acm.UpdateCertificateOptionsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateCertificateOptionsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*acm.UpdateCertificateOptionsOutput) return ret0, ret1 } // UpdateCertificateOptionsRequest indicates an expected call of UpdateCertificateOptionsRequest func (mr *MockACMAPIMockRecorder) UpdateCertificateOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCertificateOptionsRequest", reflect.TypeOf((*MockACMAPI)(nil).UpdateCertificateOptionsRequest), arg0) } // WaitUntilCertificateValidated mocks base method func (m *MockACMAPI) WaitUntilCertificateValidated(arg0 *acm.DescribeCertificateInput) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WaitUntilCertificateValidated", arg0) ret0, _ := ret[0].(error) return ret0 } // WaitUntilCertificateValidated indicates an expected call of WaitUntilCertificateValidated func (mr *MockACMAPIMockRecorder) WaitUntilCertificateValidated(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCertificateValidated", reflect.TypeOf((*MockACMAPI)(nil).WaitUntilCertificateValidated), arg0) } // WaitUntilCertificateValidatedWithContext mocks base method func (m *MockACMAPI) WaitUntilCertificateValidatedWithContext(arg0 aws.Context, arg1 *acm.DescribeCertificateInput, 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, "WaitUntilCertificateValidatedWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // WaitUntilCertificateValidatedWithContext indicates an expected call of WaitUntilCertificateValidatedWithContext func (mr *MockACMAPIMockRecorder) WaitUntilCertificateValidatedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCertificateValidatedWithContext", reflect.TypeOf((*MockACMAPI)(nil).WaitUntilCertificateValidatedWithContext), varargs...) } ================================================ FILE: acm/mock/sdk/paginators.go ================================================ package sdk import ( "github.com/aws/aws-sdk-go/service/acm" "github.com/aws/aws-sdk-go/service/acm/acmiface" ) type MockListCertificatesPagesClient struct { acmiface.ACMAPI Resp *acm.ListCertificatesOutput Error error } func (m MockListCertificatesPagesClient) ListCertificatesPages(in *acm.ListCertificatesInput, fn func(*acm.ListCertificatesOutput, bool) bool) error { if m.Error != nil { return m.Error } fn(m.Resp, true) return nil } ================================================ FILE: cloudwatchlogs/log_group.go ================================================ package cloudwatchlogs import ( "fmt" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" awscwl "github.com/aws/aws-sdk-go/service/cloudwatchlogs" "github.com/awslabs/fargatecli/console" ) type GetLogsInput struct { Filter string LogGroupName string LogStreamNames []string EndTime time.Time StartTime time.Time } type LogLine struct { EventId string LogStreamName string Message string Timestamp time.Time } func (cwl *CloudWatchLogs) CreateLogGroup(logGroupName string, a ...interface{}) string { formattedLogGroupName := fmt.Sprintf(logGroupName, a...) _, err := cwl.svc.CreateLogGroup( &awscwl.CreateLogGroupInput{ LogGroupName: aws.String(formattedLogGroupName), }, ) if err != nil { if awsErr, ok := err.(awserr.Error); ok { switch awsErr.Code() { case awscwl.ErrCodeResourceAlreadyExistsException: return formattedLogGroupName default: console.ErrorExit(awsErr, "Could not create Cloudwatch Logs log group") } } } return formattedLogGroupName } func (cwl *CloudWatchLogs) GetLogs(i *GetLogsInput) []LogLine { var logLines []LogLine input := &awscwl.FilterLogEventsInput{ LogGroupName: aws.String(i.LogGroupName), Interleaved: aws.Bool(true), } if !i.StartTime.IsZero() { input.SetStartTime(i.StartTime.UTC().UnixNano() / int64(time.Millisecond)) } if !i.EndTime.IsZero() { input.SetEndTime(i.EndTime.UTC().UnixNano() / int64(time.Millisecond)) } if i.Filter != "" { input.SetFilterPattern(i.Filter) } if len(i.LogStreamNames) > 0 { input.SetLogStreamNames(aws.StringSlice(i.LogStreamNames)) } err := cwl.svc.FilterLogEventsPages( input, func(resp *awscwl.FilterLogEventsOutput, lastPage bool) bool { for _, event := range resp.Events { logLines = append(logLines, LogLine{ EventId: aws.StringValue(event.EventId), Message: aws.StringValue(event.Message), LogStreamName: aws.StringValue(event.LogStreamName), Timestamp: time.Unix(0, aws.Int64Value(event.Timestamp)*int64(time.Millisecond)), }, ) } return true }, ) if err != nil { console.ErrorExit(err, "Could not get logs") } return logLines } ================================================ FILE: cloudwatchlogs/main.go ================================================ package cloudwatchlogs import ( "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/cloudwatchlogs" ) type CloudWatchLogs struct { svc *cloudwatchlogs.CloudWatchLogs } func New(sess *session.Session) CloudWatchLogs { return CloudWatchLogs{ svc: cloudwatchlogs.New(sess), } } ================================================ FILE: cmd/certificate.go ================================================ package cmd import ( "errors" "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" ) type certificateOperation struct { acm acm.Client output Output } func (o certificateOperation) findCertificate(domainName string) (acm.Certificate, error) { o.output.Debug("Listing certificates [API=acm Action=ListCertificate]") certificates, err := o.acm.ListCertificates() if err != nil { return acm.Certificate{}, err } certificates = certificates.GetCertificates(domainName) switch { case len(certificates) == 0: return acm.Certificate{}, errCertificateNotFound case len(certificates) > 1: return acm.Certificate{}, errCertificateTooManyFound } o.output.Debug("Describing certificate [API=acm Action=DescribeCertificate ARN=%s]", certificates[0].ARN) if err := o.acm.InflateCertificate(&certificates[0]); err != nil { return acm.Certificate{}, err } return certificates[0], nil } var ( errCertificateNotFound = errors.New("certificate not found") errCertificateTooManyFound = errors.New("too many certificates found") certificateCmd = &cobra.Command{ Use: "certificate", Short: "Manage certificates", Long: `Manages certificate Certificates are TLS certificates issued by or imported into AWS Certificate Manager for use in securing traffic between load balancers and end users. ACM provides TLS certificates free of charge for use within AWS resources.`, } ) func init() { rootCmd.AddCommand(certificateCmd) } ================================================ FILE: cmd/certificate_destroy.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" ) type certificateDestroyOperation struct { certificateOperation domainName string output Output } func (o certificateDestroyOperation) execute() { certificate, err := o.findCertificate(o.domainName) if err != nil { switch err { case errCertificateNotFound: o.output.Fatal(err, "Could not find certificate for %s", o.domainName) return case errCertificateTooManyFound: o.output.Fatal(err, "Multiple certificates found for %s, for safety please destroy the one you intend via the AWS CLI", o.domainName) return default: o.output.Fatal(err, "Could not destroy certificate") return } } o.output.Debug("Deleting certificate [API=acm Action=DeleteCertificate ARN=%s]", certificate.ARN) if err := o.acm.DeleteCertificate(certificate.ARN); err != nil { o.output.Fatal(err, "Could not destroy certificate") return } o.output.Info("Destroyed certificate %s", o.domainName) } var certificateDestroyCmd = &cobra.Command{ Use: "destroy ", Short: "Destroy certificate", Long: `Destroy certificate In order to destroy a certificate, it must not be in use by any load balancers or any other AWS resources.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { certificateDestroyOperation{ certificateOperation: certificateOperation{acm: acm.New(sess), output: output}, domainName: args[0], output: output, }.execute() }, } func init() { certificateCmd.AddCommand(certificateDestroyCmd) } ================================================ FILE: cmd/certificate_destroy_test.go ================================================ package cmd import ( "errors" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestCertificateDestroyOperation(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" domainName := "example.com" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{certificate}, nil) mockClient.EXPECT().InflateCertificate(&certificate).Return(nil) mockClient.EXPECT().DeleteCertificate(certificateARN).Return(nil) certificateDestroyOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if len(mockOutput.InfoMsgs) == 0 { t.Errorf("Expected info output from operation, got none") } } func TestCertificateDestroyOperationCertNotFound(t *testing.T) { domainName := "example.com" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{}, nil) certificateDestroyOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateDestroyOperationMoreThanOneCertFound(t *testing.T) { certificateARN1 := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificateARN2 := "arn:aws:acm:us-east-1:123456789012:certificate/abcdef01-2345-6789-0abc-def012345678" domainName := "example.com" certificate1 := acm.Certificate{ ARN: certificateARN1, DomainName: domainName, } certificate2 := acm.Certificate{ ARN: certificateARN2, DomainName: domainName, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{certificate1, certificate2}, nil) certificateDestroyOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateDestroyOperationListError(t *testing.T) { domainName := "example.com" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{}, errors.New("something went boom")) certificateDestroyOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateDestroyOperationDeleteError(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" domainName := "example.com" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{certificate}, nil) mockClient.EXPECT().InflateCertificate(&certificate).Return(nil) mockClient.EXPECT().DeleteCertificate(certificateARN).Return(errors.New(":-(")) certificateDestroyOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } ================================================ FILE: cmd/certificate_import.go ================================================ package cmd import ( "fmt" "io/ioutil" "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" ) type certificateImportOperation struct { acm acm.Client certificate []byte certificateChain []byte certificateChainFile string certificateFile string output Output privateKey []byte privateKeyFile string } func (o certificateImportOperation) execute() { if errs := o.validate(); len(errs) > 0 { o.output.Fatals(errs, "Invalid certificate import parameters") return } if errs := o.readFiles(); len(errs) > 0 { o.output.Fatals(errs, "Could not read file(s)") return } o.output.Debug("Importing certificate [API=acm Action=ImportCertificate]") arn, err := o.acm.ImportCertificate(o.certificate, o.privateKey, o.certificateChain) if err != nil { o.output.Fatal(err, "Could not import certificate") return } o.output.Info("Imported certificate [ARN=%s]", arn) } func (o certificateImportOperation) validate() []error { var errs []error if o.certificateFile == "" { errs = append(errs, fmt.Errorf("--certificate is required")) } if o.privateKeyFile == "" { errs = append(errs, fmt.Errorf("--key is required")) } return errs } func (o *certificateImportOperation) readFiles() []error { var errs []error o.output.Debug("Reading certificate [File=%s]", o.certificateFile) if certificate, err := ioutil.ReadFile(o.certificateFile); err == nil { o.certificate = certificate } else { errs = append(errs, err) } o.output.Debug("Reading private key [File=%s]", o.privateKeyFile) if privateKey, err := ioutil.ReadFile(o.privateKeyFile); err == nil { o.privateKey = privateKey } else { errs = append(errs, err) } if o.certificateChainFile != "" { o.output.Debug("Reading certificate chain [File=%s]", o.certificateChainFile) if certificateChain, err := ioutil.ReadFile(o.certificateChainFile); err == nil { o.certificateChain = certificateChain } else { errs = append(errs, err) } } return errs } var certificateImportCmd = &cobra.Command{ Use: "import --certificate --key [--chain ]", Short: "Import a certificate", Long: `Import a certificate Upload a certificate from a certificate file, a private key file, and optionally an intermediate certificate chain file. The files must be PEM-encoded and the private key must not be encrypted or protected by a passphrase. See http://docs.aws.amazon.com/acm/latest/APIReference/API_ImportCertificate.html for more details.`, Run: func(cmd *cobra.Command, args []string) { certificateImportOperation{ acm: acm.New(sess), certificateChainFile: certificateImportFlags.chain, certificateFile: certificateImportFlags.certificate, output: output, privateKeyFile: certificateImportFlags.key, }.execute() }, } var certificateImportFlags struct { certificate, key, chain string } func init() { certificateImportCmd.Flags().StringVarP(&certificateImportFlags.certificate, "certificate", "c", "", "Filename of the certificate to import") certificateImportCmd.Flags().StringVarP(&certificateImportFlags.key, "key", "k", "", "Filename of the private key used to generate the certificate") certificateImportCmd.Flags().StringVar(&certificateImportFlags.chain, "chain", "", "Filename of intermediate certificate chain") certificateCmd.AddCommand(certificateImportCmd) } ================================================ FILE: cmd/certificate_import_test.go ================================================ package cmd import ( "errors" "io/ioutil" "strings" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestCertificateImportOperation(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := readFile("testdata/certificate.crt", t) privateKey := readFile("testdata/private.key", t) certificateChain := readFile("testdata/chain.crt", t) mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ImportCertificate(certificate, privateKey, certificateChain).Return(certificateARN, nil) certificateImportOperation{ acm: mockClient, certificateChainFile: "testdata/chain.crt", certificateFile: "testdata/certificate.crt", output: mockOutput, privateKeyFile: "testdata/private.key", }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if len(mockOutput.InfoMsgs) == 0 { t.Errorf("Expected info output from operation, got none") } if !strings.Contains(mockOutput.InfoMsgs[0], "Imported certificate") { t.Errorf("Expected info output to say 'Imported certificate [ARN=%s]', got: %s", certificateARN, mockOutput.InfoMsgs[0]) } } func TestCertificateImportOperationSansChain(t *testing.T) { var certificateChain []byte certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := readFile("testdata/certificate.crt", t) privateKey := readFile("testdata/private.key", t) mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ImportCertificate(certificate, privateKey, certificateChain).Return(certificateARN, nil) certificateImportOperation{ acm: mockClient, certificateFile: "testdata/certificate.crt", output: mockOutput, privateKeyFile: "testdata/private.key", }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if len(mockOutput.InfoMsgs) == 0 { t.Errorf("Expected info output from operation, got none") } if !strings.Contains(mockOutput.InfoMsgs[0], "Imported certificate") { t.Errorf("Expected info output to say 'Imported certificate [ARN=%s]', got: %s", certificateARN, mockOutput.InfoMsgs[0]) } } func TestCertificateImportOperationMissingParameters(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} certificateImportOperation{ acm: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit, didn't") } if mockOutput.FatalMsgs[0].Msg != "Invalid certificate import parameters" { t.Errorf("Expected fatal output 'Invalid certificate import parameters', got: %s", mockOutput.FatalMsgs[0].Msg) } } func TestCertificateImportOperationBadFiles(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} certificateImportOperation{ acm: mockClient, certificateChainFile: "pretend", certificateFile: "pretend", output: mockOutput, privateKeyFile: "pretend", }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit, didn't") } if mockOutput.FatalMsgs[0].Msg != "Could not read file(s)" { t.Errorf("Expected fatal output 'Could not read file(s)', got: %s", mockOutput.FatalMsgs[0].Msg) } } func readFile(fileName string, t *testing.T) []byte { contents, err := ioutil.ReadFile(fileName) if err != nil { t.Errorf(err.Error()) } return contents } func TestCertificateImportOperationError(t *testing.T) { certificate := readFile("testdata/certificate.crt", t) privateKey := readFile("testdata/private.key", t) certificateChain := readFile("testdata/chain.crt", t) mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ImportCertificate(certificate, privateKey, certificateChain).Return("", errors.New(":-(")) certificateImportOperation{ acm: mockClient, certificateChainFile: "testdata/chain.crt", certificateFile: "testdata/certificate.crt", output: mockOutput, privateKeyFile: "testdata/private.key", }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected fatal output from operation, got none") } if !mockOutput.Exited { t.Errorf("Expected premature exit, didn't") } if mockOutput.FatalMsgs[0].Msg != "Could not import certificate" { t.Errorf("Expected fatal output 'Could not import certificate', got: %s", mockOutput.FatalMsgs[0].Msg) } } ================================================ FILE: cmd/certificate_info.go ================================================ package cmd import ( "strings" "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" ) type certificateInfoOperation struct { certificateOperation domainName string output Output } func (o certificateInfoOperation) execute() { certificate, err := o.findCertificate(o.domainName) if err != nil { switch err { case errCertificateNotFound: o.output.Info("No certificate found for %s", o.domainName) case errCertificateTooManyFound: o.output.Fatal(nil, "Multiple certificates found for %s", o.domainName) default: o.output.Fatal(err, "Could not find certificate for %s", o.domainName) } return } o.display(certificate) } func (o certificateInfoOperation) display(certificate acm.Certificate) { o.output.KeyValue("Domain Name", certificate.DomainName, 0) o.output.KeyValue("Status", Titleize(certificate.Status), 0) o.output.KeyValue("Type", Titleize(certificate.Type), 0) o.output.KeyValue("Subject Alternative Names", strings.Join(certificate.SubjectAlternativeNames, ", "), 0) if len(certificate.Validations) > 0 { rows := [][]string{ []string{"DOMAIN NAME", "STATUS", "RECORD"}, } for _, v := range certificate.Validations { rows = append(rows, []string{v.DomainName, Titleize(v.Status), v.ResourceRecordString()}) } o.output.LineBreak() o.output.Table("Validations", rows) } } var certificateInfoCmd = &cobra.Command{ Use: "info ", Short: "Inspect certificate", Long: `Inspect certificate Show extended information for a certificate. Includes each validation for the certificate which shows DNS records which must be created to validate domain ownership.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { certificateInfoOperation{ certificateOperation: certificateOperation{acm: acm.New(sess), output: output}, domainName: args[0], output: output, }.execute() }, } func init() { certificateCmd.AddCommand(certificateInfoCmd) } ================================================ FILE: cmd/certificate_info_test.go ================================================ package cmd import ( "errors" "reflect" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestCertificateInfoOperation(t *testing.T) { domainName := "example.com" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, Type: "AMAZON_ISSUED", Status: "PENDING_VALIDATION", SubjectAlternativeNames: []string{"staging1.example.com", "staging2.example.com"}, Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "SUCCESS", DomainName: "staging.example.com", ResourceRecord: acm.CertificateResourceRecord{ Name: "_beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com", Type: "CNAME", Value: "_6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws.", }, }, }, } certificateList := acm.Certificates{certificate} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) certificateInfoOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: domainName, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if len(mockOutput.KeyValueMsgs) == 0 { t.Errorf("Expected key value output from operation, got none") } if mockOutput.KeyValueMsgs["Domain Name"] != domainName { t.Errorf("Expected Domain Name == %s, got %s", domainName, mockOutput.KeyValueMsgs["Domain Name"]) } if mockOutput.KeyValueMsgs["Status"] != "Pending Validation" { t.Logf(mockOutput.KeyValueMsgs["Status"]) t.Logf(Titleize(mockOutput.KeyValueMsgs["Status"])) t.Errorf("Expected Status == Pending Validation, got %s", mockOutput.KeyValueMsgs["Status"]) } if mockOutput.KeyValueMsgs["Type"] != "Amazon Issued" { t.Errorf("Expected Type == Amazon Issued, got %s", mockOutput.KeyValueMsgs["Type"]) } if mockOutput.KeyValueMsgs["Subject Alternative Names"] != "staging1.example.com, staging2.example.com" { t.Errorf( "Expected Subject Alternative Names == staging1.example.com, staging2.example.com, got %s", mockOutput.KeyValueMsgs["Subject Alternative Names"], ) } if len(mockOutput.Tables) != 1 { t.Errorf("Expected 1 table, got %d", len(mockOutput.Tables)) } if len(mockOutput.Tables[0].Rows) != 2 { t.Errorf("Expected 2 rows , got %d", len(mockOutput.Tables[0].Rows)) } if mockOutput.Tables[0].Header != "Validations" { t.Errorf("Expected table with header Validations , got %s", mockOutput.Tables[0].Header) } if !reflect.DeepEqual(mockOutput.Tables[0].Rows[0], []string{"DOMAIN NAME", "STATUS", "RECORD"}) { t.Errorf("Expected table with validation column names , got %+v", mockOutput.Tables[0].Rows[0]) } if mockOutput.Tables[0].Rows[1][0] != "staging.example.com" { t.Errorf("Expected Validation Domain Name == staging.example.com, got %s", mockOutput.Tables[0].Rows[1][0]) } if mockOutput.Tables[0].Rows[1][1] != "Success" { t.Errorf("Expected Validation Status == Success, got %s", mockOutput.Tables[0].Rows[1][1]) } if mockOutput.Tables[0].Rows[1][2] != "CNAME _beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com -> _6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws." { t.Errorf("Expected Validation Record == CNAME _beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com -> _6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws., got %s", mockOutput.Tables[0].Rows[1][2]) } } func TestCertificateInfoOperationNotFound(t *testing.T) { certificateList := acm.Certificates{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) certificateInfoOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if mockOutput.InfoMsgs[0] != "No certificate found for example.com" { t.Errorf("Expected info 'No certificate found for example.com', got: %+v", mockOutput.InfoMsgs) } } func TestCertificateInfoOperationListError(t *testing.T) { certificateList := acm.Certificates{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, errors.New("boom")) certificateInfoOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected error output, received none") } if mockOutput.FatalMsgs[0].Msg != "Could not find certificate for example.com" { t.Errorf("Expected info 'Could not find certificate for example.com', got: %s", mockOutput.FatalMsgs[0].Msg) } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateInfoOperationDescribeError(t *testing.T) { certificate := acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", } certificateList := acm.Certificates{certificate} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(gomock.Any()).Return(errors.New("boom")) certificateInfoOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected error output, received none") } if mockOutput.FatalMsgs[0].Msg != "Could not find certificate for example.com" { t.Errorf("Expected info 'Could not find certificate for example.com', got: %s", mockOutput.FatalMsgs[0].Msg) } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } ================================================ FILE: cmd/certificate_list.go ================================================ package cmd import ( "context" "sort" "strings" "sync" "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" "golang.org/x/time/rate" ) type certificateListOperation struct { acm acm.Client output Output } func (o certificateListOperation) execute() { certificates, err := o.find() if err != nil { o.output.Fatal(err, "Could not list certificates") return } if len(certificates) == 0 { o.output.Info("No certificates found") return } rows := [][]string{ []string{"CERTIFICATE", "TYPE", "STATUS", "SUBJECT ALTERNATIVE NAMES"}, } sort.Slice(certificates, func(i, j int) bool { return certificates[i].DomainName < certificates[j].DomainName }) for _, certificate := range certificates { rows = append(rows, []string{ certificate.DomainName, Titleize(certificate.Type), Titleize(certificate.Status), strings.Join(certificate.SubjectAlternativeNames, ", "), }, ) } o.output.Table("", rows) } func (o certificateListOperation) find() (acm.Certificates, error) { var wg sync.WaitGroup o.output.Debug("Listing certificates [API=acm Action=ListCertificates]") certificates, err := o.acm.ListCertificates() if err != nil { return acm.Certificates{}, err } errs := make(chan error) done := make(chan bool) limiter := rate.NewLimiter(describeRequestLimitRate, 1) for i := 0; i < len(certificates); i++ { wg.Add(1) go func(index int) { defer wg.Done() if err := limiter.Wait(context.Background()); err == nil { o.output.Debug("Describing certificate [API=acm Action=DescribeCertificate ARN=%s]", certificates[index].ARN) if err := o.acm.InflateCertificate(&certificates[index]); err != nil { errs <- err } } }(i) } go func() { wg.Wait() done <- true }() select { case err := <-errs: return acm.Certificates{}, err case <-done: return certificates, nil } } func (o certificateListOperation) display(certificates []acm.Certificate) { } var certificateListCmd = &cobra.Command{ Use: "list", Short: "List certificates", Run: func(cmd *cobra.Command, args []string) { certificateListOperation{ acm: acm.New(sess), output: output, }.execute() }, } func init() { certificateCmd.AddCommand(certificateListCmd) } ================================================ FILE: cmd/certificate_list_test.go ================================================ package cmd import ( "errors" "reflect" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestCertificateListOperation(t *testing.T) { certificateList := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Type: "AMAZON_ISSUED", Status: "PENDING_VALIDATION", SubjectAlternativeNames: []string{"staging1.example.com", "staging2.example.com"}, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(&certificateList[0]).Return(nil) certificateListOperation{ acm: mockClient, output: mockOutput, }.execute() if len(mockOutput.Tables) != 1 { t.Errorf("Expected table, got none") } if len(mockOutput.Tables[0].Rows) != 2 { t.Errorf("Expected table with 2 rows, got %d", len(mockOutput.Tables[0].Rows)) } if !reflect.DeepEqual( mockOutput.Tables[0].Rows[0], []string{"CERTIFICATE", "TYPE", "STATUS", "SUBJECT ALTERNATIVE NAMES"}, ) { t.Errorf("Expected column headers, found %+v", mockOutput.Tables[0].Rows[0]) } if mockOutput.Tables[0].Rows[1][0] != "example.com" { t.Errorf("Expected Domain Name == example.com, found %s", mockOutput.Tables[0].Rows[1][0]) } if mockOutput.Tables[0].Rows[1][1] != "Amazon Issued" { t.Errorf("Expected Type == Amazon Issued, found %s", mockOutput.Tables[0].Rows[1][1]) } if mockOutput.Tables[0].Rows[1][2] != "Pending Validation" { t.Errorf("Expected Status == Pending Validation, found %s", mockOutput.Tables[0].Rows[1][2]) } if mockOutput.Tables[0].Rows[1][3] != "staging1.example.com, staging2.example.com" { t.Errorf("Expected Subject Alternative Names == staging1.example.com, staging2.example.com, found %s", mockOutput.Tables[0].Rows[1][3]) } } func TestCertificateListOperationOrdered(t *testing.T) { certificateList := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-f", DomainName: "f.com", }, acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-c", DomainName: "c.com", }, acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-a", DomainName: "a.com", }, acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-d", DomainName: "d.com", }, acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-e", DomainName: "e.com", }, acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012-b", DomainName: "b.com", }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil).Times(len(certificateList)) certificateListOperation{ acm: mockClient, output: mockOutput, }.execute() for i, r := range mockOutput.Tables[0].Rows { // Skip header and first row if i <= 1 { continue } // Compare domain to the domain of the previous row, check it is lexicographically subsequent if mockOutput.Tables[0].Rows[i-1][0] > r[0] { t.Errorf("Expected alphabetical order, got %+v", mockOutput.Tables[0].Rows[1:len(mockOutput.Tables[0].Rows)+1]) break } } } func TestCertificateListOperationNotFound(t *testing.T) { certificateList := acm.Certificates{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) certificateListOperation{ acm: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) > 0 { for _, fatal := range mockOutput.FatalMsgs { t.Errorf(fatal.Msg, fatal.Errors) } } if mockOutput.InfoMsgs[0] != "No certificates found" { t.Errorf("Expected info 'No certificate found', got: %+v", mockOutput.InfoMsgs) } } func TestCertificateListOperationListError(t *testing.T) { certificateList := acm.Certificates{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, errors.New("boom")) certificateListOperation{ acm: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected error output, received none") } if mockOutput.FatalMsgs[0].Msg != "Could not list certificates" { t.Errorf("Expected info 'Could not list certificates', got: %s", mockOutput.FatalMsgs[0].Msg) } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateListOperationDescribeError(t *testing.T) { certificate := acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", } certificateList := acm.Certificates{certificate} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(&certificate).Return(errors.New("boom")) certificateListOperation{ acm: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected error output, received none") } if mockOutput.FatalMsgs[0].Msg != "Could not list certificates" { t.Errorf("Expected info 'Could not list certificates', got: %s", mockOutput.FatalMsgs[0].Msg) } if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } ================================================ FILE: cmd/certificate_request.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/acm" "github.com/spf13/cobra" ) type certificateRequestOperation struct { acm acm.Client aliases []string output Output domainName string } func (o certificateRequestOperation) execute() { if errs := o.validate(); len(errs) > 0 { o.output.Fatals(errs, "Invalid certificate request parameters") return } o.output.Debug("Requesting certificate [API=acm Action=RequestCertificate]") if arn, err := o.acm.RequestCertificate(o.domainName, o.aliases); err == nil { o.output.Debug("Requested certificate [ARN=%s]", arn) } else { o.output.Fatal(err, "Could not request certificate") return } o.output.Info("Requested certificate for %s", o.domainName) o.output.LineBreak() o.output.Say("You must validate ownership of the domain name for the certificate to be issued.", 0) o.output.LineBreak() o.output.Say("If your domain is hosted using Amazon Route 53, this can be done automatically by running:", 0) o.output.Say("fargate certificate validate %s", 1, o.domainName) o.output.LineBreak() o.output.Say("If not, you must manually create the DNS records returned by running:", 0) o.output.Say("fargate certificate info %s", 1, o.domainName) } func (o certificateRequestOperation) validate() []error { var errors []error if err := acm.ValidateDomainName(o.domainName); err != nil { errors = append(errors, err) } for _, alias := range o.aliases { if err := acm.ValidateAlias(alias); err != nil { errors = append(errors, err) } } return errors } var certificateRequestCmd = &cobra.Command{ Use: "request ", Short: "Request a certificate", Long: `Request a certificate Certificates can be for a fully qualified domain name (e.g. www.example.com) or a wildcard domain name (e.g. *.example.com). You can add aliases to a certificate by specifying additional domain names via the --alias flag. To add multiple aliases, pass --alias multiple times. By default, AWS Certificate Manager has a limit of 10 domain names per certificate, but this limit can be raised by AWS support.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { certificateRequestOperation{ acm: acm.New(sess), aliases: certificateRequestFlags.aliases, output: output, domainName: args[0], }.execute() }, } var certificateRequestFlags struct { aliases []string } func init() { certificateRequestCmd.Flags().StringSliceVarP(&certificateRequestFlags.aliases, "alias", "a", []string{}, `Additional domain names to be included in the certificate (can be specified multiple times)`) certificateCmd.AddCommand(certificateRequestCmd) } ================================================ FILE: cmd/certificate_request_test.go ================================================ package cmd import ( "fmt" "strings" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestCertificateRequestOperation(t *testing.T) { certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" domainName := "example.com" aliases := []string{"www.example.com"} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := certificateRequestOperation{ acm: mockClient, aliases: aliases, domainName: domainName, output: mockOutput, } mockClient.EXPECT().RequestCertificate(domainName, aliases).Return(certificateARN, nil) operation.execute() if len(mockOutput.InfoMsgs) == 0 { t.Errorf("Expected info output from operation, got none") } } func TestCertificateRequestOperationError(t *testing.T) { domainName := "example.com" aliases := []string{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := certificateRequestOperation{ acm: mockClient, aliases: aliases, domainName: domainName, output: mockOutput, } mockClient.EXPECT().RequestCertificate(domainName, aliases).Return("", fmt.Errorf("oops, something went wrong")) operation.execute() if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } if len(mockOutput.FatalMsgs) == 0 { t.Errorf("Expected error output from operation, got none") } } func TestCertificateRequestOperationInvalid(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := certificateRequestOperation{ acm: mockClient, domainName: "z", // Invalid output: mockOutput, } operation.execute() if !mockOutput.Exited { t.Errorf("Expected premature exit; didn't") } } func TestCertificateRequestOperationValidateInvalidDomainName(t *testing.T) { operation := certificateRequestOperation{ domainName: "z", // Invalid } errs := operation.validate() if len(errs) != 1 { t.Errorf("Invalid number of errors; want 1, got: %d", len(errs)) } if strings.Index(errs[0].Error(), "The domain name requires at least 2 octets") == -1 { t.Errorf("Unexpected error; want: 'The domain name requires at leasr 2 octets', got: %s", errs[0].Error()) } } func TestCertificateRequestOperationValidateInvalidAlias(t *testing.T) { operation := certificateRequestOperation{ domainName: "example.com", aliases: []string{"z"}, // Invalid } errs := operation.validate() if len(errs) != 1 { t.Errorf("Invalid number of errors; want 1, got: %d", len(errs)) } if strings.Index(errs[0].Error(), "An alias requires at least 2 octets") == -1 { t.Errorf("Unexpected error; want: 'An alias requires at least 2 octets', got: %s", errs[0].Error()) } } ================================================ FILE: cmd/certificate_test.go ================================================ package cmd import ( "reflect" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ) func TestFindCertificate(t *testing.T) { certificate := acm.Certificate{ DomainName: "www.example.com", ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", Status: "ISSUED", Type: "AMAZON_ISSUED", } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{certificate}, nil) mockClient.EXPECT().InflateCertificate(&certificate).Return(nil) operation := certificateOperation{ acm: mockClient, output: mockOutput, } foundCertificate, err := operation.findCertificate("www.example.com") if err != nil { t.Errorf("Expected no error, got %v", err) } if !reflect.DeepEqual(foundCertificate, certificate) { t.Errorf("Expected to find %+v, got: %v", certificate, foundCertificate) } } func TestFindCertificateNotFound(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(acm.Certificates{}, nil) operation := certificateOperation{ acm: mockClient, output: mockOutput, } foundCertificate, err := operation.findCertificate("www.example.com") if err != errCertificateNotFound { t.Errorf("Expected errCertificateNotFound, got %v", err) } if !reflect.DeepEqual(foundCertificate, acm.Certificate{}) { t.Errorf("Expected empty Certificate, got: %v", foundCertificate) } } func TestFindCertificateTooManyFound(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{DomainName: "www.example.com", ARN: "arn:1"}, acm.Certificate{DomainName: "www.example.com", ARN: "arn:2"}, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().ListCertificates().Return(certificates, nil) operation := certificateOperation{ acm: mockClient, output: mockOutput, } foundCertificate, err := operation.findCertificate("www.example.com") if err != errCertificateTooManyFound { t.Errorf("Expected errCertificateTooManyFound, got %v", err) } if !reflect.DeepEqual(foundCertificate, acm.Certificate{}) { t.Errorf("Expected empty Certificate, got: %v", foundCertificate) } } ================================================ FILE: cmd/certificate_validate.go ================================================ package cmd import ( "fmt" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/route53" "github.com/spf13/cobra" ) type certificateValidateOperation struct { certificateOperation domainName string output Output route53 route53.Client } func (o certificateValidateOperation) execute() { certificate, err := o.findCertificate(o.domainName) if err != nil { o.output.Fatal(err, "Could not validate certificate") return } if !certificate.IsPendingValidation() { o.output.Fatal(fmt.Errorf("certificate %s is in state %s", o.domainName, Humanize(certificate.Status)), "Could not validate certificate") return } o.output.Debug("Listing hosted zones [API=route53 Action=ListHostedZones]") hostedZones, err := o.route53.ListHostedZones() if err != nil { o.output.Fatal(err, "Could not validate certificate") return } for _, v := range certificate.Validations { switch { case v.IsPendingValidation(): if zone, ok := hostedZones.FindSuperDomainOf(v.DomainName); ok { o.output.Debug("Creating resource record [API=route53 Action=ChangeResourceRecordSets HostedZone=%s]", zone.ID) id, err := o.route53.CreateResourceRecord( route53.CreateResourceRecordInput{ HostedZoneID: zone.ID, RecordType: v.ResourceRecord.Type, Name: v.ResourceRecord.Name, Value: v.ResourceRecord.Value, }, ) if err != nil { o.output.Fatal(err, "Could not validate certificate") return } o.output.Debug("Created resource record [ChangeID=%s]", id) o.output.Info("[%s] created validation record", v.DomainName) } else { o.output.Warn("[%s] could not find zone in Amazon Route 53", v.DomainName) } case v.IsSuccess(): o.output.Info("[%s] already validated", v.DomainName) case v.IsFailed(): o.output.Fatal(nil, "[%s] failed validation", v.DomainName) return default: o.output.Warn("[%s] unexpected status: %s", v.DomainName, Humanize(v.Status)) } } } var certificateValidateCmd = &cobra.Command{ Use: "validate ", Args: cobra.ExactArgs(1), Short: "Validate certificate ownership", Long: `Validate certificate ownership fargate will automatically create DNS validation record to verify ownership for any domain names that are hosted within Amazon Route 53. If your certificate has aliases, a validation record will be attempted per alias. Any records whose domains are hosted in other DNS hosting providers or in other DNS accounts and cannot be automatically validated will have the necessary records output. These records are also available in fargate certificate info \. AWS Certificate Manager may take up to several hours after the DNS records are created to complete validation and issue the certificate.`, Run: func(cmd *cobra.Command, args []string) { certificateValidateOperation{ certificateOperation: certificateOperation{acm: acm.New(sess), output: output}, domainName: args[0], output: output, route53: route53.New(sess), }.execute() }, } func init() { certificateCmd.AddCommand(certificateValidateCmd) } ================================================ FILE: cmd/certificate_validate_test.go ================================================ package cmd import ( "errors" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" acmclient "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" "github.com/awslabs/fargatecli/route53" route53client "github.com/awslabs/fargatecli/route53/mock/client" ) func TestCertificateValidateOperation(t *testing.T) { resourceRecordType := "CNAME" resourceRecordName := "_beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com" resourceRecordValue := "_6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws." hostedZones := route53.HostedZones{ route53.HostedZone{ Name: "example.com.", ID: "Z2FDTNDATAQYW2", }, } certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "PENDING_VALIDATION", DomainName: "example.com", ResourceRecord: acm.CertificateResourceRecord{ Name: resourceRecordName, Type: resourceRecordType, Value: resourceRecordValue, }, }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createResourceRecordInput := route53.CreateResourceRecordInput{ HostedZoneID: hostedZones[0].ID, RecordType: resourceRecordType, Name: resourceRecordName, Value: resourceRecordValue, } mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(hostedZones, nil) mockRoute53Client.EXPECT().CreateResourceRecord(createResourceRecordInput).Return("/change/1", nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.InfoMsgs) == 0 { t.Error("Expected info output, got none") } else if mockOutput.InfoMsgs[0] != "[example.com] created validation record" { t.Errorf("Expected info output == '[example.com] created validation record', got: %s", mockOutput.InfoMsgs[0]) } } func TestCertificateValidateOperationFindCertificateError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(acm.Certificates{}, errors.New("boom")) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not validate certificate" { t.Errorf("Expected fatal output == 'Could not validate certificate', got: %+v", mockOutput.FatalMsgs[0]) } } func TestCertificateValidateOperationListHostedZonesError(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, errors.New("boom")) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not validate certificate" { t.Errorf("Expected fatal output == 'Could not validate certificate', got: %+v", mockOutput.FatalMsgs[0]) } } func TestCertificateValidateOperationInvalidState(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "FAILED", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{}, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") t.FailNow() } if mockOutput.FatalMsgs[0].Msg != "Could not validate certificate" { t.Errorf("Expected fatal output == 'Could not validate certificate', got: %s", mockOutput.FatalMsgs[0]) } if mockOutput.FatalMsgs[0].Errors[0].Error() != "certificate example.com is in state failed" { t.Errorf("Expected error == 'certificate example.com is in state failed', got: %s", mockOutput.FatalMsgs[0].Errors[0]) } } func TestCertificateValidateOperationZoneNotFound(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "PENDING_VALIDATION", DomainName: "example.com", }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.WarnMsgs) == 0 { t.Error("Expected warn output, got none") } else if mockOutput.WarnMsgs[0] != "[example.com] could not find zone in Amazon Route 53" { t.Errorf("Expected warn output == '[example.com] could not find zone in Amaozn Route 53', got: %s", mockOutput.WarnMsgs[0]) } } func TestCertificateValidateOperationValidationSuccess(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "SUCCESS", DomainName: "example.com", }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.InfoMsgs) == 0 { t.Error("Expected info output, got none") } else if mockOutput.InfoMsgs[0] != "[example.com] already validated" { t.Errorf("Expected info output == '[example.com] already validated', got: %s", mockOutput.InfoMsgs[0]) } } func TestCertificateValidateOperationValidationFailed(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "FAILED", DomainName: "example.com", }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "[example.com] failed validation" { t.Errorf("Expected fatal output == '[example.com] failed validation', got: %s", mockOutput.FatalMsgs[0]) } } func TestCertificateValidateOperationValidationUnknown(t *testing.T) { certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "SOME_UNKNOWN_STATUS", DomainName: "example.com", }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, nil) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.WarnMsgs) == 0 { t.Error("Expected warn output, got none") } else if mockOutput.WarnMsgs[0] != "[example.com] unexpected status: some unknown status" { t.Errorf("Expected warn output == '[example.com] unexpected status: some unknown status', got: %s", mockOutput.WarnMsgs[0]) } } func TestCertificateValidateOperationRecordSetError(t *testing.T) { resourceRecordType := "CNAME" resourceRecordName := "_beeed67ae3f2d83f6cd3e19a8064947b.staging.example.com" resourceRecordValue := "_6ddc33cd42c3fe3d5eca4cb075013a0a.acm-validations.aws." hostedZones := route53.HostedZones{ route53.HostedZone{ Name: "example.com.", ID: "Z2FDTNDATAQYW2", }, } certificates := acm.Certificates{ acm.Certificate{ ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", DomainName: "example.com", Status: "PENDING_VALIDATION", Type: "AMAZON_ISSUED", Validations: []acm.CertificateValidation{ acm.CertificateValidation{ Status: "PENDING_VALIDATION", DomainName: "example.com", ResourceRecord: acm.CertificateResourceRecord{ Name: resourceRecordName, Type: resourceRecordType, Value: resourceRecordValue, }, }, }, }, } mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53Client := route53client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createResourceRecordInput := route53.CreateResourceRecordInput{ HostedZoneID: hostedZones[0].ID, RecordType: resourceRecordType, Name: resourceRecordName, Value: resourceRecordValue, } mockACMClient.EXPECT().ListCertificates().Return(certificates, nil) mockACMClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) mockRoute53Client.EXPECT().ListHostedZones().Return(hostedZones, nil) mockRoute53Client.EXPECT().CreateResourceRecord(createResourceRecordInput).Return("", errors.New("boom")) certificateValidateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, output: mockOutput, }, domainName: "example.com", output: mockOutput, route53: mockRoute53Client, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not validate certificate" { t.Errorf("Expected fatal output == 'Could not validate certificate', got: %+v", mockOutput.FatalMsgs[0]) } } ================================================ FILE: cmd/lb.go ================================================ package cmd import ( "errors" "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) const defaultTargetGroupFormat = "%s-default" type lbOperation struct { elbv2 elbv2.Client output Output } func (o lbOperation) findLB(lbName string) (elbv2.LoadBalancer, error) { o.output.Debug("Finding load balancer[API=elb2 Action=DescribeLoadBalancers]") loadBalancers, err := o.elbv2.DescribeLoadBalancersByName([]string{lbName}) if err != nil { return elbv2.LoadBalancer{}, err } switch { case len(loadBalancers) == 0: return elbv2.LoadBalancer{}, errLBNotFound case len(loadBalancers) > 1: return elbv2.LoadBalancer{}, errLBTooManyFound } return loadBalancers[0], nil } var ( errLBNotFound = errors.New("load balancer not found") errLBTooManyFound = errors.New("too many load balancers found") lbCmd = &cobra.Command{ Use: "lb", Short: "Manage load balancers", Long: `Manage load balancers Load balancers distribute incoming traffic between the tasks within a service for HTTP/HTTPS and TCP applications. HTTP/HTTPS load balancers can route to multiple services based upon rules you specify when you create a new service.`, } ) func init() { rootCmd.AddCommand(lbCmd) } ================================================ FILE: cmd/lb_alias.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/elbv2" "github.com/awslabs/fargatecli/route53" "github.com/spf13/cobra" ) type lbAliasOperation struct { lbOperation aliasDomain string lbName string output Output route53 route53.Client } func (o lbAliasOperation) execute() { loadBalancer, err := o.findLB(o.lbName) if err != nil { o.output.Fatal(err, "Could not alias load balancer") return } hostedZones, err := o.route53.ListHostedZones() if err != nil { o.output.Fatal(err, "Could not alias load balancer") return } if hostedZone, ok := hostedZones.FindSuperDomainOf(o.aliasDomain); ok { o.output.Debug("Creating alias record [API=route53 Action=CreateResourceRecordSet]") id, err := o.route53.CreateAlias( route53.CreateAliasInput{ HostedZoneID: hostedZone.ID, RecordType: "A", Name: o.aliasDomain, Target: loadBalancer.DNSName, TargetHostedZoneID: loadBalancer.HostedZoneID, }, ) if err != nil { o.output.Fatal(err, "Could not alias load balancer") return } o.output.Debug("Created alias record [ChangeID=%s]", id) o.output.Info("Created alias record (%s -> %s)", o.aliasDomain, loadBalancer.DNSName) } else { o.output.Warn("Could not find hosted zone for %s", o.aliasDomain) o.output.Say("If you're hosting this domain elsewhere or in another AWS account, please manually create the alias record:", 1) o.output.Say("%s -> %s", 1, o.aliasDomain, loadBalancer.DNSName) } } var lbAliasCmd = &cobra.Command{ Use: "alias ", Args: cobra.ExactArgs(2), Short: "Create a load balancer alias record", Long: `Create a load balancer alias record Create an alias record to the load balancer for domains that are hosted within Amazon Route 53 and within the same AWS account. If you're using another DNS provider or host your domains in a different account, you will need to manually create this record. `, Run: func(cmd *cobra.Command, args []string) { lbAliasOperation{ aliasDomain: args[1], lbName: args[0], lbOperation: lbOperation{elbv2: elbv2.New(sess), output: output}, output: output, route53: route53.New(sess), }.execute() }, } func init() { lbCmd.AddCommand(lbAliasCmd) } ================================================ FILE: cmd/lb_alias_test.go ================================================ package cmd import ( "errors" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/cmd/mock" "github.com/awslabs/fargatecli/elbv2" elbv2client "github.com/awslabs/fargatecli/elbv2/mock/client" "github.com/awslabs/fargatecli/route53" route53client "github.com/awslabs/fargatecli/route53/mock/client" ) var ( lb = elbv2.LoadBalancer{ ARN: "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188", DNSName: "my-load-balancer-424835706.us-west-2.elb.amazonaws.com", HostedZoneID: "Z2P70J7EXAMPLE", VPCID: "vpc-3ac0fb5f", Name: "web", SecurityGroupIDs: []string{"sg-5943793c"}, Status: "active", SubnetIDs: []string{"subnet-8360a9e7"}, Type: "application", } hostedZone = route53.HostedZone{ Name: "example.com.", ID: "Z111111QQQQQQQ", } ) func TestLBAliasOperation(t *testing.T) { domainName := "example.com." lbName := "web" dnsName := "my-load-balancer-424835706.us-west-2.elb.amazonaws.com" hostedZoneID := "Z2P70J7EXAMPLE" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockRoute53Client := route53client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createAliasInput := route53.CreateAliasInput{ HostedZoneID: hostedZone.ID, RecordType: "A", Name: domainName, Target: dnsName, TargetHostedZoneID: hostedZoneID, } operation := lbAliasOperation{ lbOperation: lbOperation{ elbv2: mockELBV2Client, output: mockOutput, }, aliasDomain: domainName, lbName: lbName, output: mockOutput, route53: mockRoute53Client, } mockELBV2Client.EXPECT().DescribeLoadBalancersByName([]string{"web"}).Return(elbv2.LoadBalancers{lb}, nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{hostedZone}, nil) mockRoute53Client.EXPECT().CreateAlias(createAliasInput).Return("ID", nil) operation.execute() if len(mockOutput.InfoMsgs) == 0 { t.Errorf("Expected info output from operation, got none") } } func TestLBAliasOperationFindLBError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockRoute53Client := route53client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := lbAliasOperation{ lbOperation: lbOperation{ elbv2: mockELBV2Client, output: mockOutput, }, aliasDomain: "example.com", lbName: "web", output: mockOutput, route53: mockRoute53Client, } mockELBV2Client.EXPECT().DescribeLoadBalancersByName([]string{"web"}).Return(elbv2.LoadBalancers{}, errors.New("boom")) operation.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not alias load balancer" { t.Errorf("Expected fatal output == 'Could not alias load balancer', got: %s", mockOutput.FatalMsgs[0]) } } func TestLBAliasOperationListHostedZonesError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockRoute53Client := route53client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := lbAliasOperation{ lbOperation: lbOperation{ elbv2: mockELBV2Client, output: mockOutput, }, aliasDomain: "example.com", lbName: "web", output: mockOutput, route53: mockRoute53Client, } mockELBV2Client.EXPECT().DescribeLoadBalancersByName([]string{"web"}).Return(elbv2.LoadBalancers{elbv2.LoadBalancer{}}, nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, errors.New("boom")) operation.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not alias load balancer" { t.Errorf("Expected fatal output == 'Could not alias load balancer', got: %s", mockOutput.FatalMsgs[0]) } } func TestLBAliasOperationAliasError(t *testing.T) { domainName := "example.com." lbName := "web" dnsName := "my-load-balancer-424835706.us-west-2.elb.amazonaws.com" hostedZoneID := "Z2P70J7EXAMPLE" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockRoute53Client := route53client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createAliasInput := route53.CreateAliasInput{ HostedZoneID: hostedZone.ID, RecordType: "A", Name: domainName, Target: dnsName, TargetHostedZoneID: hostedZoneID, } operation := lbAliasOperation{ lbOperation: lbOperation{ elbv2: mockELBV2Client, output: mockOutput, }, aliasDomain: domainName, lbName: lbName, output: mockOutput, route53: mockRoute53Client, } mockELBV2Client.EXPECT().DescribeLoadBalancersByName([]string{"web"}).Return(elbv2.LoadBalancers{lb}, nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{hostedZone}, nil) mockRoute53Client.EXPECT().CreateAlias(createAliasInput).Return("", errors.New("boom")) operation.execute() if len(mockOutput.FatalMsgs) == 0 { t.Error("Expected fatal output, got none") } else if mockOutput.FatalMsgs[0].Msg != "Could not alias load balancer" { t.Errorf("Expected fatal output == 'Could not alias load balancer', got: %s", mockOutput.FatalMsgs[0]) } } func TestLBAliasOperationHostedZoneNotFound(t *testing.T) { domainName := "example.com." lbName := "web" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockRoute53Client := route53client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} operation := lbAliasOperation{ lbOperation: lbOperation{ elbv2: mockELBV2Client, output: mockOutput, }, aliasDomain: domainName, lbName: lbName, output: mockOutput, route53: mockRoute53Client, } mockELBV2Client.EXPECT().DescribeLoadBalancersByName([]string{"web"}).Return(elbv2.LoadBalancers{lb}, nil) mockRoute53Client.EXPECT().ListHostedZones().Return(route53.HostedZones{}, nil) operation.execute() if len(mockOutput.WarnMsgs) == 0 { t.Error("Expected warn output, got none") } else if mockOutput.WarnMsgs[0] != "Could not find hosted zone for example.com." { t.Errorf("Expected warn output == 'Could not find hosted zone for example.com.', got: %s", mockOutput.WarnMsgs[0]) } } ================================================ FILE: cmd/lb_create.go ================================================ package cmd import ( "fmt" "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/ec2" "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) type lbCreateOperation struct { certificateARNs []string certificateOperation elbv2 elbv2.Client lbType string lbScheme string lbName string output Output ports []Port vpcOperation } func (o *lbCreateOperation) setPorts(inputPorts []string) []error { var ( errs []error protocols []string ) if len(inputPorts) == 0 { return append(errs, fmt.Errorf("at least one --port must be specified")) } ports, errs := inflatePorts(inputPorts) if len(errs) > 0 { return errs } for _, port := range ports { errs = append(errs, validatePort(port)...) protocols = append(protocols, port.Protocol) } for _, protocol := range protocols { if protocol == "TCP" { for _, protocol := range protocols { if protocol == "HTTP" || protocol == "HTTPS" { return append(errs, fmt.Errorf("load balancers do not support commingled TCP and HTTP/HTTPS ports")) } } } } if len(errs) == 0 { o.ports = ports } return errs } func (o *lbCreateOperation) inferType() error { if len(o.ports) > 0 { switch o.ports[0].Protocol { case "HTTP", "HTTPS": o.lbType = "application" case "TCP": o.lbType = "network" default: return fmt.Errorf("could not infer type from port settings") } } return nil } func (o *lbCreateOperation) setCertificateARNs(domainNames []string) []error { var ( certificateARNs []string errs []error ) for _, domainName := range domainNames { if certificate, err := o.findCertificate(domainName); err == nil { if certificate.IsIssued() { certificateARNs = append(certificateARNs, certificate.ARN) } else { errs = append(errs, fmt.Errorf("certificate %s is in state %s", domainName, Humanize(certificate.Status))) } } else { switch err { case errCertificateNotFound: errs = append(errs, fmt.Errorf("no certificate found for %s", domainName)) case errCertificateTooManyFound: errs = append(errs, fmt.Errorf("multiple certificates found for %s", domainName)) default: errs = append(errs, fmt.Errorf("could not find certificate ARN: %v", err)) } } } if len(errs) == 0 { o.certificateARNs = certificateARNs } return errs } func (o lbCreateOperation) validate() (errs []error) { if o.lbName == "" { errs = append(errs, fmt.Errorf("--name is required")) } if o.lbType == "application" && len(o.subnetIDs) < 2 { errs = append(errs, fmt.Errorf("HTTP/HTTPS load balancers require two subnet IDs from unique Availability Zones")) } if o.lbType == "network" && len(o.securityGroupIDs) > 0 { errs = append(errs, fmt.Errorf("security groups can only be specified for HTTP/HTTPS load balancers")) } return } func (o lbCreateOperation) execute() { defaultTargetGroupName := fmt.Sprintf(defaultTargetGroupFormat, o.lbName) loadBalancerARN, err := o.elbv2.CreateLoadBalancer( elbv2.CreateLoadBalancerParameters{ Name: o.lbName, SecurityGroupIDs: o.securityGroupIDs, SubnetIDs: o.subnetIDs, Type: o.lbType, Scheme: o.lbScheme, }, ) if err != nil { o.output.Fatal(err, "Could not create load balancer") return } o.output.Debug("Creating target group [Name=%s]", defaultTargetGroupName) defaultTargetGroupARN, err := o.elbv2.CreateTargetGroup( elbv2.CreateTargetGroupParameters{ Name: defaultTargetGroupName, Port: o.ports[0].Number, Protocol: o.ports[0].Protocol, VPCID: o.vpcID, }, ) if err != nil { o.output.Fatal(err, "Could not create default target group") return } o.output.Debug("Created target group [ARN=%s]", defaultTargetGroupARN) for _, port := range o.ports { o.output.Debug("Creating listener [Port=%d Protocol=%s]", port.Number, port.Protocol) listenerARN, err := o.elbv2.CreateListener( elbv2.CreateListenerParameters{ CertificateARNs: o.certificateARNs, DefaultTargetGroupARN: defaultTargetGroupARN, LoadBalancerARN: loadBalancerARN, Port: port.Number, Protocol: port.Protocol, }, ) if err != nil { o.output.Fatal(err, "Could not create listener") return } o.output.Debug("Created listener [ARN=%s]", listenerARN) } o.output.Info("Created load balancer %s", o.lbName) } func newLBCreateOperation( lbName, lbScheme string, certificates, ports, securityGroupIDs, subnetIDs []string, output Output, acm acm.Client, ec2 ec2.Client, elbv2 elbv2.Client, ) (operation lbCreateOperation, errors []error) { operation = lbCreateOperation{ certificateOperation: certificateOperation{acm: acm, output: output}, elbv2: elbv2, lbName: lbName, lbScheme: lbScheme, output: output, vpcOperation: vpcOperation{ec2: ec2, output: output}, } if errs := operation.setPorts(ports); len(errs) > 0 { errors = append(errors, errs...) } if err := operation.inferType(); err != nil { errors = append(errors, err) } if len(certificates) > 0 { if errs := operation.setCertificateARNs(certificates); len(errs) > 0 { errors = append(errors, errs...) } } if len(subnetIDs) > 0 { if err := operation.setSubnetIDs(subnetIDs); err != nil { errors = append(errors, err) } } else { if err := operation.setDefaultSubnetIDs(); err != nil { errors = append(errors, err) } } if len(securityGroupIDs) > 0 { operation.setSecurityGroupIDs(securityGroupIDs) } else if operation.lbType == "application" { if err := operation.setDefaultSecurityGroupID(); err != nil { errors = append(errors, err) } } errors = append(errors, operation.validate()...) return } var lbCreateCmd = &cobra.Command{ Use: "create --port ", Args: cobra.ExactArgs(1), Short: "Create a load balancer", Long: `Create a load balancer At least one port must be specified for the load balancer listener via the --port flag and a port expression of protocol:port-number. For example, if you wanted an HTTP load balancer to listen on port 80, you would specify HTTP:80. Valid protocols are HTTP, HTTPS, and TCP. You can specify multiple listeners by passing the --port flag with a port expression multiple times. You cannot mix TCP ports with HTTP/HTTPS ports on a single load balancer. You can optionally include certificates to secure HTTPS ports by passed the --certificate flag along with a certificate name. This option can be specified multiple times to add additional certificates to a single load balancer which uses Service Name Identification (SNI) to select the appropriate certificate for the request. By default, the load balancer will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. HTTP/HTTPS load balancers require at least two subnets attached while a TCP load balancer requires only one. You may only specify a single subnet from each availability zone. Security groups can optionally be specified for HTTP/HTTPS load balancers by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the load balancer.`, Run: func(cmd *cobra.Command, args []string) { operation, errs := newLBCreateOperation( args[0], lbCreateFlags.scheme, lbCreateFlags.certificates, lbCreateFlags.ports, lbCreateFlags.securityGroupIDs, lbCreateFlags.subnetIDs, output, acm.New(sess), ec2.New(sess), elbv2.New(sess), ) if len(errs) > 0 { output.Fatals(errs, "Invalid command line flags") return } operation.execute() }} var lbCreateFlags struct { scheme string certificates []string ports []string securityGroupIDs []string subnetIDs []string } func init() { lbCreateCmd.Flags().StringSliceVarP(&lbCreateFlags.certificates, "certificate", "c", []string{}, "Name of certificate to add (can be specified multiple times)") lbCreateCmd.Flags().StringSliceVarP(&lbCreateFlags.ports, "port", "p", []string{}, "Port to listen on [e.g., 80, 443, http:8080, https:8443, tcp:1935] (can be specified multiple times)") lbCreateCmd.Flags().StringSliceVar(&lbCreateFlags.securityGroupIDs, "security-group-id", []string{}, "ID of a security group to apply to the load balancer (can be specified multiple times)") lbCreateCmd.Flags().StringSliceVar(&lbCreateFlags.subnetIDs, "subnet-id", []string{}, "ID of a subnet to place the load balancer (can be specified multiple times)") lbCreateCmd.Flags().StringVarP(&lbCreateFlags.scheme, "scheme", "s", "internet-facing", "Scheme of the load balancer") lbCmd.AddCommand(lbCreateCmd) } ================================================ FILE: cmd/lb_create_test.go ================================================ package cmd import ( "errors" "reflect" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/acm" acmclient "github.com/awslabs/fargatecli/acm/mock/client" "github.com/awslabs/fargatecli/cmd/mock" ec2client "github.com/awslabs/fargatecli/ec2/mock/client" "github.com/awslabs/fargatecli/elbv2" elbv2client "github.com/awslabs/fargatecli/elbv2/mock/client" ) var ( certificates = acm.Certificates{ acm.Certificate{ DomainName: "example.com", ARN: "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012", }, } ) func TestLBCreateOperation(t *testing.T) { lbName := "lb" lbType := "application" lbARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/lb/50dc6c495c0c9188" tgARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-targets/73e2d6bc24d8a067" listenerARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2" subnetIDs := []string{"subnet-1234567", "subnet-abcdef8"} securityGroupIDs := []string{"sg-1234567"} vpcID := "vpc-1234567" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createLoadBalancerInput := elbv2.CreateLoadBalancerParameters{ Name: lbName, SecurityGroupIDs: securityGroupIDs, SubnetIDs: subnetIDs, Type: lbType, } createTargetGroupInput := elbv2.CreateTargetGroupParameters{ Name: "lb-default", Port: 80, Protocol: "HTTP", VPCID: vpcID, } createListenerInput := elbv2.CreateListenerParameters{ DefaultTargetGroupARN: tgARN, LoadBalancerARN: lbARN, Port: 80, Protocol: "HTTP", } mockELBV2Client.EXPECT().CreateLoadBalancer(createLoadBalancerInput).Return(lbARN, nil) mockELBV2Client.EXPECT().CreateTargetGroup(createTargetGroupInput).Return(tgARN, nil) mockELBV2Client.EXPECT().CreateListener(createListenerInput).Return(listenerARN, nil) operation := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, }, vpcOperation: vpcOperation{ ec2: mockEC2Client, securityGroupIDs: securityGroupIDs, subnetIDs: subnetIDs, vpcID: vpcID, }, elbv2: mockELBV2Client, lbType: lbType, lbName: lbName, output: mockOutput, ports: []Port{Port{80, "HTTP"}}, } operation.execute() if len(mockOutput.InfoMsgs) != 1 { t.Fatalf("expected 1 info msg, got: %d", len(mockOutput.InfoMsgs)) } if expected, got := "Created load balancer lb", mockOutput.InfoMsgs[0]; expected != got { t.Errorf("expected: %s, got: %s", expected, got) } } func TestLBCreateOperationLBError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockELBV2Client.EXPECT().CreateLoadBalancer(gomock.Any()).Return("", errors.New("boom")) operation := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, }, vpcOperation: vpcOperation{ ec2: mockEC2Client, }, elbv2: mockELBV2Client, lbType: "application", lbName: "web", output: mockOutput, ports: []Port{Port{80, "HTTP"}}, } operation.execute() if len(mockOutput.FatalMsgs) != 1 { t.Fatalf("expected 1 fatal msg, got: %d", len(mockOutput.FatalMsgs)) } if expected, got := "Could not create load balancer", mockOutput.FatalMsgs[0].Msg; expected != got { t.Errorf("expected: %s, got: %s", expected, got) } } func TestLBCreateOperationTargetGroupError(t *testing.T) { lbName := "lb" lbType := "application" lbARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/lb/50dc6c495c0c9188" subnetIDs := []string{"subnet-1234567", "subnet-abcdef8"} securityGroupIDs := []string{"sg-1234567"} vpcID := "vpc-1234567" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createLoadBalancerInput := elbv2.CreateLoadBalancerParameters{ Name: lbName, SecurityGroupIDs: securityGroupIDs, SubnetIDs: subnetIDs, Type: lbType, } createTargetGroupInput := elbv2.CreateTargetGroupParameters{ Name: "lb-default", Port: 80, Protocol: "HTTP", VPCID: vpcID, } mockELBV2Client.EXPECT().CreateLoadBalancer(createLoadBalancerInput).Return(lbARN, nil) mockELBV2Client.EXPECT().CreateTargetGroup(createTargetGroupInput).Return("", errors.New("boom")) operation := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, }, vpcOperation: vpcOperation{ ec2: mockEC2Client, securityGroupIDs: securityGroupIDs, subnetIDs: subnetIDs, vpcID: vpcID, }, elbv2: mockELBV2Client, lbType: lbType, lbName: lbName, output: mockOutput, ports: []Port{Port{80, "HTTP"}}, } operation.execute() if len(mockOutput.FatalMsgs) != 1 { t.Fatalf("expected 1 fatal msg, got: %d", len(mockOutput.FatalMsgs)) } if expected, got := "Could not create default target group", mockOutput.FatalMsgs[0].Msg; expected != got { t.Errorf("expected: %s, got: %s", expected, got) } } func TestLBCreateOperationListenerError(t *testing.T) { lbName := "lb" lbType := "application" lbARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/lb/50dc6c495c0c9188" tgARN := "arn:aws:elasticloadbalancing:us-east-1:123456789012:targetgroup/my-targets/73e2d6bc24d8a067" subnetIDs := []string{"subnet-1234567", "subnet-abcdef8"} securityGroupIDs := []string{"sg-1234567"} vpcID := "vpc-1234567" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2Client := elbv2client.NewMockClient(mockCtrl) mockACMClient := acmclient.NewMockClient(mockCtrl) mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} createLoadBalancerInput := elbv2.CreateLoadBalancerParameters{ Name: lbName, SecurityGroupIDs: securityGroupIDs, SubnetIDs: subnetIDs, Type: lbType, } createTargetGroupInput := elbv2.CreateTargetGroupParameters{ Name: "lb-default", Port: 80, Protocol: "HTTP", VPCID: vpcID, } createListenerInput := elbv2.CreateListenerParameters{ DefaultTargetGroupARN: tgARN, LoadBalancerARN: lbARN, Port: 80, Protocol: "HTTP", } mockELBV2Client.EXPECT().CreateLoadBalancer(createLoadBalancerInput).Return(lbARN, nil) mockELBV2Client.EXPECT().CreateTargetGroup(createTargetGroupInput).Return(tgARN, nil) mockELBV2Client.EXPECT().CreateListener(createListenerInput).Return("", errors.New("boom")) operation := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockACMClient, }, vpcOperation: vpcOperation{ ec2: mockEC2Client, securityGroupIDs: securityGroupIDs, subnetIDs: subnetIDs, vpcID: vpcID, }, elbv2: mockELBV2Client, lbType: lbType, lbName: lbName, output: mockOutput, ports: []Port{Port{80, "HTTP"}}, } operation.execute() if len(mockOutput.FatalMsgs) != 1 { t.Fatalf("expected 1 fatal msg, got: %d", len(mockOutput.FatalMsgs)) } if expected, got := "Could not create listener", mockOutput.FatalMsgs[0].Msg; expected != got { t.Errorf("expected: %s, got: %s", expected, got) } } func TestSetPorts(t *testing.T) { tests := []struct { inputPorts []string outputPorts []Port }{ {[]string{"80"}, []Port{Port{80, "HTTP"}}}, {[]string{"http:80"}, []Port{Port{80, "HTTP"}}}, {[]string{"hTTp:80"}, []Port{Port{80, "HTTP"}}}, {[]string{"HTTP:80"}, []Port{Port{80, "HTTP"}}}, {[]string{"443"}, []Port{Port{443, "HTTPS"}}}, {[]string{"https:443"}, []Port{Port{443, "HTTPS"}}}, {[]string{"hTTpS:443"}, []Port{Port{443, "HTTPS"}}}, {[]string{"HTTPS:443"}, []Port{Port{443, "HTTPS"}}}, {[]string{"8080"}, []Port{Port{8080, "TCP"}}}, {[]string{"tcp:8080"}, []Port{Port{8080, "TCP"}}}, {[]string{"HTTP:8080"}, []Port{Port{8080, "HTTP"}}}, {[]string{"80", "443"}, []Port{Port{80, "HTTP"}, Port{443, "HTTPS"}}}, {[]string{"tcp:3386", "TCP:5000"}, []Port{Port{3386, "TCP"}, Port{5000, "TCP"}}}, } for _, test := range tests { operation := lbCreateOperation{} errs := operation.setPorts(test.inputPorts) if len(errs) > 0 { t.Fatalf("expected no errors, got: %v", errs) } if !reflect.DeepEqual(operation.ports, test.outputPorts) { t.Errorf("expected ports %v, got: %v", test.outputPorts, operation.ports) } } } func TestSetPortsMissing(t *testing.T) { o := lbCreateOperation{} errs := o.setPorts([]string{}) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := errors.New("at least one --port must be specified"); errs[0].Error() != expected.Error() { t.Errorf("expected error %v, got: %v", expected, errs[0]) } } func TestSetPortsCommingled(t *testing.T) { o := lbCreateOperation{} errs := o.setPorts([]string{"HTTP:80", "TCP:3386"}) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := errors.New("load balancers do not support commingled TCP and HTTP/HTTPS ports"); errs[0].Error() != expected.Error() { t.Errorf("expected error %v, got: %v", expected, errs[0]) } } func TestSetPortsCantInflate(t *testing.T) { o := lbCreateOperation{} errs := o.setPorts([]string{"bargle"}) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := errors.New("could not parse port number from bargle"); errs[0].Error() != expected.Error() { t.Errorf("expected error %v, got: %v", expected, errs[0]) } } func TestSetPortsInvalidNumber(t *testing.T) { o := lbCreateOperation{} errs := o.setPorts([]string{"555555555"}) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := errors.New("invalid port 555555555 (specify within 1 - 65535)"); errs[0].Error() != expected.Error() { t.Errorf("expected error %v, got: %v", expected, errs[0]) } } func TestSetPortsInvalidProtocol(t *testing.T) { o := lbCreateOperation{} errs := o.setPorts([]string{"SMTP:25"}) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := errors.New("invalid protocol SMTP (specify TCP, HTTP, or HTTPS)"); errs[0].Error() != expected.Error() { t.Errorf("expected error %v, got: %v", expected, errs[0]) } } func TestInferType(t *testing.T) { tests := []struct { inputPorts []string lbType string }{ {[]string{"80"}, "application"}, {[]string{"443"}, "application"}, {[]string{"80", "443"}, "application"}, {[]string{"8080"}, "network"}, {[]string{"1"}, "network"}, {[]string{"5000", "2112"}, "network"}, } for _, test := range tests { o := lbCreateOperation{} o.setPorts(test.inputPorts) err := o.inferType() if err != nil { t.Fatalf("expected no error, got: %v", err) } if o.lbType != test.lbType { t.Errorf("expected: %s, got: %s", test.lbType, o.lbType) } } } func TestInferTypeNoPorts(t *testing.T) { o := lbCreateOperation{} err := o.inferType() if err != nil { t.Errorf("expected no error, got: %v", err) } if o.lbType != "" { t.Errorf("expected type to not be inferred, got: %s", o.lbType) } } func TestInferTypeInvalidProtocol(t *testing.T) { o := lbCreateOperation{ ports: []Port{Port{80, "INTERWEB"}}, } err := o.inferType() if err == nil { t.Fatalf("expected error, got none") } if expected := "could not infer type from port settings"; err.Error() != expected { t.Errorf("expected error %s, got: %v", expected, err) } } func TestSetCertificateARNs(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() domainName := "example.com" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, Status: "ISSUED", } certificateList := acm.Certificates{certificate} mockClient := acmclient.NewMockClient(mockCtrl) mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) o := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, } errs := o.setCertificateARNs([]string{domainName}) if len(errs) > 0 { t.Fatalf("expected no errors, got: %v", errs) } if len(o.certificateARNs) != 1 { t.Fatalf("expected 1 certificate ARN, got: %d", len(o.certificateARNs)) } if o.certificateARNs[0] != certificateARN { t.Errorf("expected certificate ARN %s, got: %s", certificateARN, o.certificateARNs[0]) } } func TestSetCertificateARNsNotIssued(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() domainName := "example.com" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, Status: "FAILED", } certificateList := acm.Certificates{certificate} mockClient := acmclient.NewMockClient(mockCtrl) mockClient.EXPECT().ListCertificates().Return(certificateList, nil) mockClient.EXPECT().InflateCertificate(gomock.Any()).Return(nil) o := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, } errs := o.setCertificateARNs([]string{domainName}) if len(errs) == 0 { t.Fatalf("expected 1 errors, got none") } if expected := "certificate example.com is in state failed"; errs[0].Error() != expected { t.Fatalf("expected error %s, got: %v", expected, errs[0]) } if len(o.certificateARNs) > 0 { t.Fatalf("expected no certificate ARNs, got: %v", o.certificateARNs) } } func TestSetCertificateARNsNotFound(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := acmclient.NewMockClient(mockCtrl) mockClient.EXPECT().ListCertificates().Return(acm.Certificates{}, nil) o := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, } errs := o.setCertificateARNs([]string{"example.com"}) if len(errs) == 0 { t.Fatalf("expected 1 errors, got none") } if expected := "no certificate found for example.com"; errs[0].Error() != expected { t.Fatalf("expected error %s, got: %v", expected, errs[0]) } if len(o.certificateARNs) > 0 { t.Fatalf("expected no certificate ARNs, got: %v", o.certificateARNs) } } func TestSetCertificateARNsTooManyFound(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() certificate := acm.Certificate{DomainName: "example.com"} certificateList := acm.Certificates{certificate, certificate} mockClient := acmclient.NewMockClient(mockCtrl) mockClient.EXPECT().ListCertificates().Return(certificateList, nil) o := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, } errs := o.setCertificateARNs([]string{"example.com"}) if len(errs) == 0 { t.Fatalf("expected 1 errors, got none") } if expected := "multiple certificates found for example.com"; errs[0].Error() != expected { t.Fatalf("expected error %s, got: %v", expected, errs[0]) } if len(o.certificateARNs) > 0 { t.Fatalf("expected no certificate ARNs, got: %v", o.certificateARNs) } } func TestSetCertificateARNsError(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := acmclient.NewMockClient(mockCtrl) mockClient.EXPECT().ListCertificates().Return(acm.Certificates{}, errors.New("boom")) o := lbCreateOperation{ certificateOperation: certificateOperation{ acm: mockClient, output: mockOutput, }, } errs := o.setCertificateARNs([]string{"example.com"}) if len(errs) == 0 { t.Fatalf("expected 1 errors, got none") } if expected := "could not find certificate ARN: boom"; errs[0].Error() != expected { t.Fatalf("expected error %s, got: %v", expected, errs[0]) } if len(o.certificateARNs) > 0 { t.Fatalf("expected no certificate ARNs, got: %v", o.certificateARNs) } } func TestValidate(t *testing.T) { o := lbCreateOperation{ lbName: "web", lbType: "application", vpcOperation: vpcOperation{ subnetIDs: []string{"subnet-abcdef", "subnet-1234567"}, }, } errs := o.validate() if len(errs) > 0 { t.Errorf("expected no errors, got: %v", errs) } } func TestValidateNoName(t *testing.T) { o := lbCreateOperation{ lbType: "application", vpcOperation: vpcOperation{ subnetIDs: []string{"subnet-abcdef", "subnet-1234567"}, }, } errs := o.validate() if len(errs) != 1 { t.Fatalf("expected 1 error, got: %v", errs) } if expected := "--name is required"; errs[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, errs) } } func TestValidateApplicationLBNoSubnets(t *testing.T) { o := lbCreateOperation{ lbName: "web", lbType: "application", } errs := o.validate() if len(errs) != 1 { t.Fatalf("expected 1 error, got: %v", errs) } if expected := "HTTP/HTTPS load balancers require two subnet IDs from unique Availability Zones"; errs[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, errs) } } func TestValidateNetworkLBWithSGs(t *testing.T) { o := lbCreateOperation{ lbName: "web", lbType: "network", vpcOperation: vpcOperation{ securityGroupIDs: []string{"sg-abcdef"}, }, } errs := o.validate() if len(errs) != 1 { t.Fatalf("expected 1 error, got: %v", errs) } if expected := "security groups can only be specified for HTTP/HTTPS load balancers"; errs[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, errs) } } func TestNewLBCreateOperation(t *testing.T) { domainName := "example.com" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" certificate := acm.Certificate{ ARN: certificateARN, DomainName: domainName, Status: "ISSUED", } mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockACM := acmclient.NewMockClient(mockCtrl) mockELBV2 := elbv2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) mockACM.EXPECT().ListCertificates().Return(acm.Certificates{certificate}, nil) mockACM.EXPECT().InflateCertificate(gomock.Any()).Return(nil) o, errs := newLBCreateOperation( "web", "internet-facing", []string{"example.com"}, []string{"80", "443"}, []string{"sg-abcdef"}, []string{"subnet-1234567", "subnet-abcdef"}, mockOutput, mockACM, mockEC2, mockELBV2, ) if len(errs) > 0 { t.Fatalf("expected no error, got: %v", errs) } if o.acm != mockACM { t.Errorf("acm client not set") } if o.ec2 != mockEC2 { t.Errorf("ec2 client not set") } if o.elbv2 != mockELBV2 { t.Errorf("elbv2 client not set") } if o.output != mockOutput { t.Errorf("output not set") } if o.lbName != "web" { t.Errorf("expected lbName == web, got: %s", o.lbName) } if len(o.ports) != 2 { t.Fatalf("expected 2 ports, got: %d", len(o.ports)) } if o.ports[0].Number != 80 || o.ports[0].Protocol != "HTTP" { t.Errorf("expected port HTTP:80, got: %v", o.ports) } if o.ports[1].Number != 443 || o.ports[1].Protocol != "HTTPS" { t.Errorf("expected port HTTPS:443, got: %v", o.ports) } if o.lbType != "application" { t.Errorf("expected lbType == application, got: %s", o.lbType) } if o.certificateARNs[0] != certificateARN { t.Errorf("expected certificate ARN %s, got: %s", certificateARN, o.certificateARNs) } if o.securityGroupIDs[0] != "sg-abcdef" { t.Errorf("expected security group ID == sg-abcdef, got: %v", o.securityGroupIDs) } if o.subnetIDs[0] != "subnet-1234567" || o.subnetIDs[1] != "subnet-abcdef" { t.Errorf("expected subnet ID == subnet-1234567, subnet-abcdef, got: %v", o.subnetIDs) } } func TestNewLBCreateOperationDefaults(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockACM := acmclient.NewMockClient(mockCtrl) mockELBV2 := elbv2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) mockEC2.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil) mockEC2.EXPECT().GetDefaultSecurityGroupID().Return("sg-abcdef", nil) o, errs := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"80"}, []string{}, []string{}, mockOutput, mockACM, mockEC2, mockELBV2, ) if len(errs) > 0 { t.Fatalf("expected no error, got: %v", errs) } if o.securityGroupIDs[0] != "sg-abcdef" { t.Errorf("expected security group ID == sg-abcdef, got: %v", o.securityGroupIDs) } if o.subnetIDs[0] != "subnet-1234567" || o.subnetIDs[1] != "subnet-abcdef" { t.Errorf("expected subnet ID == subnet-1234567, subnet-abcdef, got: %v", o.subnetIDs) } } func TestNewLBCreateOperationDefaultsWithSGCreate(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockACM := acmclient.NewMockClient(mockCtrl) mockELBV2 := elbv2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) mockEC2.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil) mockEC2.EXPECT().GetDefaultSecurityGroupID().Return("", nil) mockEC2.EXPECT().CreateDefaultSecurityGroup().Return("sg-abcdef", nil) mockEC2.EXPECT().AuthorizeAllSecurityGroupIngress("sg-abcdef").Return(nil) o, errs := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"80"}, []string{}, []string{}, mockOutput, mockACM, mockEC2, mockELBV2, ) if len(errs) > 0 { t.Fatalf("expected no error, got: %v", errs) } if o.securityGroupIDs[0] != "sg-abcdef" { t.Errorf("expected security group ID == sg-abcdef, got: %v", o.securityGroupIDs) } if o.subnetIDs[0] != "subnet-1234567" || o.subnetIDs[1] != "subnet-abcdef" { t.Errorf("expected subnet ID == subnet-1234567, subnet-abcdef, got: %v", o.subnetIDs) } } func TestNewLBCreateOperationNoName(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() ec2 := ec2client.NewMockClient(mockCtrl) ec2.EXPECT().GetSubnetVPCID(gomock.Any()).Return("vpc-1234567", nil) _, err := newLBCreateOperation( "", "internet-facing", []string{}, []string{"80"}, []string{"sg-abcdef"}, []string{"subnet-abcdef", "subnet-1234567"}, mockOutput, acmclient.NewMockClient(mockCtrl), ec2, elbv2client.NewMockClient(mockCtrl), ) if err == nil { t.Fatalf("expected errors, got none") } if expected := "--name is required"; err[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestNewLBCreateOperationNoPort(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567"}, nil) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) _, err := newLBCreateOperation( "web", "internet-facing", []string{}, []string{}, []string{}, []string{}, mockOutput, acmclient.NewMockClient(mockCtrl), mockEC2, elbv2client.NewMockClient(mockCtrl), ) if err == nil { t.Fatalf("expected errors, got none") } if expected := "at least one --port must be specified"; err[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestNewLBCreateOperationDefaultSubnets(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567"}, nil) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("", errors.New("boom")) _, err := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"445"}, []string{}, []string{}, mockOutput, acmclient.NewMockClient(mockCtrl), mockEC2, elbv2client.NewMockClient(mockCtrl), ) if err == nil { t.Fatalf("expected errors, got none") } if expected := "boom"; err[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestNewLBCreateOperationDescribeSubnetsError(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() ec2 := ec2client.NewMockClient(mockCtrl) ec2.EXPECT().GetSubnetVPCID(gomock.Any()).Return("", errors.New("boom")) _, err := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"80"}, []string{"sg-abcdef"}, []string{"subnet-abcdef", "subnet-1234567"}, mockOutput, acmclient.NewMockClient(mockCtrl), ec2, elbv2client.NewMockClient(mockCtrl), ) if err == nil { t.Fatalf("expected errors, got none") } if expected := "boom"; err[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestNewLBCreateOperationInvalidProtocol(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() ec2 := ec2client.NewMockClient(mockCtrl) ec2.EXPECT().GetSubnetVPCID(gomock.Any()).Return("vpc-1234567", nil) _, err := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"SMTP:25"}, []string{"sg-abcdef"}, []string{"subnet-abcdef", "subnet-1234567"}, mockOutput, acmclient.NewMockClient(mockCtrl), ec2, elbv2client.NewMockClient(mockCtrl), ) if err == nil { t.Fatalf("expected errors, got none") } if expected := "invalid protocol SMTP (specify TCP, HTTP, or HTTPS)"; err[0].Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestNewLBCreateOperationUseDefaultSG(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() ec2 := ec2client.NewMockClient(mockCtrl) ec2.EXPECT().GetDefaultSecurityGroupID().Return("sg-1234567", nil) ec2.EXPECT().GetSubnetVPCID(gomock.Any()).Return("vpc-1234567", nil) o, err := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"80"}, []string{}, []string{"subnet-abcdef", "subnet-1234567"}, mockOutput, acmclient.NewMockClient(mockCtrl), ec2, elbv2client.NewMockClient(mockCtrl), ) if err != nil { t.Fatalf("expected no errors, got: %v", err) } if o.securityGroupIDs[0] != "sg-1234567" { t.Errorf("expected SG sg-1234567, got: %v", o.securityGroupIDs) } } func TestNewLBCreateOperationDefaultSGError(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() ec2 := ec2client.NewMockClient(mockCtrl) ec2.EXPECT().GetDefaultSecurityGroupID().Return("", errors.New("boom")) ec2.EXPECT().GetSubnetVPCID(gomock.Any()).Return("vpc-1234567", nil) _, errs := newLBCreateOperation( "web", "internet-facing", []string{}, []string{"80"}, []string{}, []string{"subnet-abcdef", "subnet-1234567"}, mockOutput, acmclient.NewMockClient(mockCtrl), ec2, elbv2client.NewMockClient(mockCtrl), ) if len(errs) == 0 { t.Fatalf("expected error, got none") } if expected := "boom"; errs[0].Error() != expected { t.Errorf("expected error %s, got: %v", expected, errs) } } func TestNewLBCreateOperationCertificateError(t *testing.T) { mockOutput := &mock.Output{} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2 := ec2client.NewMockClient(mockCtrl) mockACM := acmclient.NewMockClient(mockCtrl) mockELBV2 := elbv2client.NewMockClient(mockCtrl) mockEC2.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) mockACM.EXPECT().ListCertificates().Return(acm.Certificates{}, errors.New("boom")) _, errs := newLBCreateOperation( "web", "internet-facing", []string{"example.com"}, []string{"80", "443"}, []string{"sg-abcdef"}, []string{"subnet-1234567", "subnet-abcdef"}, mockOutput, mockACM, mockEC2, mockELBV2, ) if len(errs) != 1 { t.Fatalf("expected error, got none") } if expected := "could not find certificate ARN: boom"; errs[0].Error() != expected { t.Errorf("expected error %s, got: %v", expected, errs) } } ================================================ FILE: cmd/lb_destroy.go ================================================ package cmd import ( "fmt" "github.com/awslabs/fargatecli/console" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) type LoadBalancerDestroyOperation struct { LoadBalancerName string } var loadBalancerDestroyCmd = &cobra.Command{ Use: "destroy ", Short: "Destroy load balancer", Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &LoadBalancerDestroyOperation{ LoadBalancerName: args[0], } destroyLoadBalancer(operation) }, } func init() { lbCmd.AddCommand(loadBalancerDestroyCmd) } func destroyLoadBalancer(operation *LoadBalancerDestroyOperation) { elbv2 := ELBV2.New(sess) elbv2.DeleteLoadBalancer(operation.LoadBalancerName) elbv2.DeleteTargetGroup(fmt.Sprintf(defaultTargetGroupFormat, operation.LoadBalancerName)) console.Info("Destroyed load balancer %s", operation.LoadBalancerName) } ================================================ FILE: cmd/lb_info.go ================================================ package cmd import ( "fmt" "os" "sort" "strings" "text/tabwriter" ACM "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) type LbInfoOperation struct { LoadBalancerName string } var lbInfoCmd = &cobra.Command{ Use: "info ", Short: "Inspect load balancer", Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &LbInfoOperation{ LoadBalancerName: args[0], } getLoadBalancerInfo(operation) }, } func init() { lbCmd.AddCommand(lbInfoCmd) } func getLoadBalancerInfo(operation *LbInfoOperation) { elbv2 := ELBV2.New(sess) acm := ACM.New(sess) ecs := ECS.New(sess, clusterName) loadBalancer := elbv2.DescribeLoadBalancer(operation.LoadBalancerName) services := ecs.ListServices() console.KeyValue("Load Balancer Name", "%s\n", loadBalancer.Name) console.KeyValue("Status", "%s\n", Humanize(loadBalancer.Status)) console.KeyValue("Type", "%s\n", Humanize(loadBalancer.Type)) console.KeyValue("DNS Name", "%s\n", loadBalancer.DNSName) console.KeyValue("Subnets", "%s\n", strings.Join(loadBalancer.SubnetIDs, ", ")) console.KeyValue("Security Groups", "%s\n", strings.Join(loadBalancer.SecurityGroupIDs, ", ")) console.KeyValue("Ports", "\n") for _, listener := range elbv2.GetListeners(loadBalancer.ARN) { var ruleCount int console.KeyValue(" "+listener.String(), "\n") if len(listener.CertificateARNs) > 0 { certificateDomains := acm.ListCertificateDomainNames(listener.CertificateARNs) console.KeyValue(" Certificates", "%s\n", strings.Join(certificateDomains, ", ")) } w := new(tabwriter.Writer) w.Init(os.Stdout, 4, 2, 2, ' ', 0) console.KeyValue(" Rules", "\n") rules := elbv2.DescribeRules(listener.ARN) sort.Slice(rules, func(i, j int) bool { return rules[i].Priority > rules[j].Priority }) for _, rule := range rules { serviceName := fmt.Sprintf("Unknown (%s)", rule.TargetGroupARN) if strings.Contains(rule.TargetGroupARN, fmt.Sprintf("/%s-default/", loadBalancer.Name)) { continue } for _, service := range services { if service.TargetGroupArn == rule.TargetGroupARN { serviceName = service.Name } } fmt.Fprintf(w, " %d\t%s\t%s\n", rule.Priority, rule.String(), serviceName) ruleCount++ } if ruleCount == 0 { fmt.Println(" None") } w.Flush() } } ================================================ FILE: cmd/lb_list.go ================================================ package cmd import ( "context" "fmt" "sort" "sync" "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" "golang.org/x/time/rate" ) type lbListOperation struct { elbv2 elbv2.Client output Output } func (o lbListOperation) execute() { loadBalancers, err := o.find() if err != nil { o.output.Fatal(err, "Could not list load balancers") return } if len(loadBalancers) == 0 { o.output.Info("No load balancers found") return } rows := [][]string{ []string{"NAME", "TYPE", "STATUS", "DNS NAME", "PORTS"}, } sort.Slice(loadBalancers, func(i, j int) bool { return loadBalancers[i].Name < loadBalancers[j].Name }) for _, loadBalancer := range loadBalancers { rows = append(rows, []string{ loadBalancer.Name, Titleize(loadBalancer.Type), Titleize(loadBalancer.Status), loadBalancer.DNSName, fmt.Sprintf("%s", loadBalancer.Listeners), }, ) } o.output.Table("", rows) } func (o lbListOperation) find() (elbv2.LoadBalancers, error) { var wg sync.WaitGroup o.output.Debug("Describing Load Balancers [API=elbv2 Action=DescribeLoadBalancers]") loadBalancers, err := o.elbv2.DescribeLoadBalancers() if err != nil { return elbv2.LoadBalancers{}, err } errs := make(chan error) done := make(chan bool) limiter := rate.NewLimiter(describeRequestLimitRate, 1) for i := 0; i < len(loadBalancers); i++ { wg.Add(1) go func(index int) { defer wg.Done() if err := limiter.Wait(context.Background()); err == nil { o.output.Debug("Describing Listeners [API=elbv2 Action=DescribeListeners LoadBalancerArn=%s]", loadBalancers[index].ARN) listeners, err := o.elbv2.DescribeListeners(loadBalancers[index].ARN) if err != nil { errs <- err } loadBalancers[index].Listeners = listeners } }(i) } go func() { wg.Wait() done <- true }() select { case err := <-errs: return elbv2.LoadBalancers{}, err case <-done: return loadBalancers, nil } } var lbListCmd = &cobra.Command{ Use: "list", Short: "List load balancers", Run: func(cmd *cobra.Command, args []string) { lbListOperation{ elbv2: elbv2.New(sess), output: output, }.execute() }, } func init() { lbCmd.AddCommand(lbListCmd) } ================================================ FILE: cmd/lb_list_test.go ================================================ package cmd import ( "errors" "reflect" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/cmd/mock" "github.com/awslabs/fargatecli/elbv2" elbv2client "github.com/awslabs/fargatecli/elbv2/mock/client" ) func TestLBListOperation(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := elbv2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} loadBalancer1 := elbv2.LoadBalancer{ ARN: "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/lb/50dc6c495c0c9188", DNSName: "test-12345678.us-east-1.elb.amazonaws.com", Name: "test", Type: "application", Status: "active", } loadBalancer2 := elbv2.LoadBalancer{ ARN: "arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/lb/93fa3d386bec918a", DNSName: "test-abcdef.us-east-1.elb.amazonaws.com", Name: "test2", Type: "application", Status: "active", } listener1 := elbv2.Listener{ ARN: "arn:aws:elasticloadbalancing:us-east-1:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2", Port: 80, Protocol: "HTTP", } listener2 := elbv2.Listener{ ARN: "arn:aws:elasticloadbalancing:us-east-1:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2", Port: 8080, Protocol: "HTTP", } loadBalancers := elbv2.LoadBalancers{loadBalancer1, loadBalancer2} listeners1 := elbv2.Listeners{listener1} listeners2 := elbv2.Listeners{listener2} mockClient.EXPECT().DescribeLoadBalancers().Return(loadBalancers, nil) mockClient.EXPECT().DescribeListeners(loadBalancer1.ARN).Return(listeners1, nil) mockClient.EXPECT().DescribeListeners(loadBalancer2.ARN).Return(listeners2, nil) lbListOperation{ elbv2: mockClient, output: mockOutput, }.execute() if len(mockOutput.Tables) == 0 { t.Fatalf("expected table, got none") } if len(mockOutput.Tables[0].Rows) != 3 { t.Errorf("expected table with 3 rows, got %d", len(mockOutput.Tables[0].Rows)) } if expected, got := []string{"NAME", "TYPE", "STATUS", "DNS NAME", "PORTS"}, mockOutput.Tables[0].Rows[0]; !reflect.DeepEqual(expected, got) { t.Errorf("expected column headers: %v, got: %v", expected, got) } row1 := mockOutput.Tables[0].Rows[1] if row1[0] != loadBalancer1.Name { t.Errorf("expected name: %s, got: %s", loadBalancer1.Name, row1[0]) } if expected := Titleize(loadBalancer1.Type); row1[1] != expected { t.Errorf("expected type: %s, got: %s", expected, row1[1]) } if expected := Titleize(loadBalancer1.Status); row1[2] != expected { t.Errorf("expected status: %s, got: %s", expected, row1[2]) } if row1[3] != loadBalancer1.DNSName { t.Errorf("expected DNS name: %s, got: %s", loadBalancer1.DNSName, row1[3]) } if expected := "HTTP:80"; row1[4] != expected { t.Errorf("expected ports: %s, got: %s", expected, row1[4]) } row2 := mockOutput.Tables[0].Rows[2] if row2[0] != loadBalancer2.Name { t.Errorf("expected name: %s, got: %s", loadBalancer2.Name, row2[0]) } if expected := Titleize(loadBalancer2.Type); row2[1] != expected { t.Errorf("expected type: %s, got: %s", expected, row2[1]) } if expected := Titleize(loadBalancer2.Status); row2[2] != expected { t.Errorf("expected status: %s, got: %s", expected, row2[2]) } if row2[3] != loadBalancer2.DNSName { t.Errorf("expected DNS name: %s, got: %s", loadBalancer1.DNSName, row2[3]) } if expected := "HTTP:8080"; row2[4] != expected { t.Errorf("expected ports: %s, got: %s", expected, row2[4]) } } func TestLBListOperationLBDescribeError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := elbv2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().DescribeLoadBalancers().Return(elbv2.LoadBalancers{}, errors.New("boom")) lbListOperation{ elbv2: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Fatalf("expected fatal output, got none") } if expected, got := "Could not list load balancers", mockOutput.FatalMsgs[0].Msg; got != expected { t.Errorf("expected fatal output: %s, got: %s", expected, got) } } func TestLBListOperationListenerDescribeError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := elbv2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} loadBalancers := elbv2.LoadBalancers{ elbv2.LoadBalancer{ARN: "lbARN"}, } mockClient.EXPECT().DescribeLoadBalancers().Return(loadBalancers, nil) mockClient.EXPECT().DescribeListeners("lbARN").Return(elbv2.Listeners{}, errors.New("boom")) lbListOperation{ elbv2: mockClient, output: mockOutput, }.execute() if len(mockOutput.FatalMsgs) == 0 { t.Fatalf("expected fatal output, got none") } if expected, got := "Could not list load balancers", mockOutput.FatalMsgs[0].Msg; got != expected { t.Errorf("expected fatal output: %s, got: %s", expected, got) } } func TestLBListOperationNoneFound(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockClient := elbv2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockClient.EXPECT().DescribeLoadBalancers().Return(elbv2.LoadBalancers{}, nil) lbListOperation{ elbv2: mockClient, output: mockOutput, }.execute() if len(mockOutput.InfoMsgs) == 0 { t.Fatalf("expected info output, got none") } if expected, got := "No load balancers found", mockOutput.InfoMsgs[0]; got != expected { t.Errorf("expected info output: %s, got: %s", expected, got) } } ================================================ FILE: cmd/logs.go ================================================ package cmd import ( "fmt" "math/rand" "strings" "time" lru "github.com/hashicorp/golang-lru" CWL "github.com/awslabs/fargatecli/cloudwatchlogs" "github.com/awslabs/fargatecli/console" ) const ( timeFormat = "2006-01-02 15:04:05" timeFormatWithZone = "2006-01-02 15:04:05 MST" logStreamNameFormat = "fargate/%s/%s" eventCacheSize = 10000 ) type Empty struct{} type GetLogsOperation struct { LogGroupName string Namespace string EndTime time.Time Filter string Follow bool LogStreamColors map[string]int LogStreamNames []string StartTime time.Time EventCache *lru.Cache } func (o *GetLogsOperation) AddStartTime(rawStartTime string) { if rawStartTime != "" { o.StartTime = o.parseTime(rawStartTime) } } func (o *GetLogsOperation) AddEndTime(rawEndTime string) { if rawEndTime != "" { o.EndTime = o.parseTime(rawEndTime) } } func (o *GetLogsOperation) AddTasks(tasks []string) { for _, task := range tasks { logStreamName := fmt.Sprintf(logStreamNameFormat, o.Namespace, task) o.LogStreamNames = append(o.LogStreamNames, logStreamName) } } func (o *GetLogsOperation) Validate() { if o.Follow && !o.EndTime.IsZero() { console.ErrorExit(fmt.Errorf("--end-time cannot be specified if following"), "Invalid command line flags") } } func (o *GetLogsOperation) GetStreamColor(logStreamName string) int { if o.LogStreamColors == nil { o.LogStreamColors = make(map[string]int) } if o.LogStreamColors[logStreamName] == 0 { o.LogStreamColors[logStreamName] = rand.Intn(256) } return o.LogStreamColors[logStreamName] } func (o *GetLogsOperation) SeenEvent(eventId string) bool { if o.EventCache == nil { o.EventCache, _ = lru.New(eventCacheSize) } if !o.EventCache.Contains(eventId) { o.EventCache.Add(eventId, Empty{}) return false } else { return true } } func (o *GetLogsOperation) parseTime(rawTime string) time.Time { var t time.Time if duration, err := time.ParseDuration(strings.ToLower(rawTime)); err == nil { return time.Now().Add(duration) } if t, err := time.Parse(timeFormat, rawTime); err == nil { return t } if t, err := time.Parse(timeFormatWithZone, rawTime); err == nil { return t } console.ErrorExit(fmt.Errorf("Could not parse %s", rawTime), "Invalid command line flags") return t } func GetLogs(operation *GetLogsOperation) { rand.Seed(time.Now().UTC().UnixNano()) if operation.Follow { followLogs(operation) } else { getLogs(operation) } } func followLogs(operation *GetLogsOperation) { ticker := time.NewTicker(time.Second) if operation.StartTime.IsZero() { operation.StartTime = time.Now() } for { getLogs(operation) if newStartTime := time.Now().Add(-10 * time.Second); newStartTime.After(operation.StartTime) { operation.StartTime = newStartTime } <-ticker.C } } func getLogs(operation *GetLogsOperation) { cwl := CWL.New(sess) input := &CWL.GetLogsInput{ LogStreamNames: operation.LogStreamNames, LogGroupName: operation.LogGroupName, Filter: operation.Filter, StartTime: operation.StartTime, EndTime: operation.EndTime, } for _, logLine := range cwl.GetLogs(input) { streamColor := operation.GetStreamColor(logLine.LogStreamName) if !operation.SeenEvent(logLine.EventId) { console.LogLine(logLine.LogStreamName, logLine.Message, streamColor) } } } ================================================ FILE: cmd/mock/output.go ================================================ package mock import ( "fmt" "sync" ) type Output struct { DebugMsgs []string Exited bool FatalMsgs []Fatal InfoMsgs []string KeyValueMsgs map[string]string SayMsgs []string Tables []Table WarnMsgs []string lock sync.Mutex } type Table struct { Header string Rows [][]string } type Fatal struct { Errors []error Msg string } func (o *Output) Info(msg string, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() o.InfoMsgs = append(o.InfoMsgs, fmt.Sprintf(msg, a...)) } func (o *Output) Warn(msg string, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() o.WarnMsgs = append(o.WarnMsgs, fmt.Sprintf(msg, a...)) } func (o *Output) Fatal(err error, msg string, a ...interface{}) { o.Fatals([]error{err}, msg, a...) } func (o *Output) Fatals(errs []error, msg string, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() o.FatalMsgs = append(o.FatalMsgs, Fatal{Msg: fmt.Sprintf(msg, a...), Errors: errs}) o.Exited = true } func (o *Output) Say(msg string, indent int, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() o.SayMsgs = append(o.SayMsgs, fmt.Sprintf(msg, a...)) } func (o *Output) Debug(msg string, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() o.DebugMsgs = append(o.DebugMsgs, fmt.Sprintf(msg, a...)) } func (o *Output) KeyValue(key, value string, indent int, a ...interface{}) { o.lock.Lock() defer o.lock.Unlock() if o.KeyValueMsgs == nil { o.KeyValueMsgs = make(map[string]string) } o.KeyValueMsgs[key] = value } func (o *Output) Table(header string, rows [][]string) { o.lock.Lock() defer o.lock.Unlock() o.Tables = append(o.Tables, Table{Header: header, Rows: rows}) } func (o *Output) LineBreak() { } ================================================ FILE: cmd/output.go ================================================ package cmd import ( "fmt" "os" "strings" "text/tabwriter" "github.com/kyokomi/emoji" "github.com/mgutz/ansi" ) var ( debug = emoji.Sprintf(" :wrench: ") info = emoji.Sprintf(" :information_source: ") warning = emoji.Sprintf(" :warning: ") blue = ansi.ColorCode("blue+bh") orange = ansi.ColorCode("214+bh") red = ansi.ColorCode("red+bh") reset = ansi.ColorCode("reset") white = ansi.ColorCode("white+bh") ) // Output represents a channel for sending messages to a user. type Output interface { Debug(string, ...interface{}) Fatal(error, string, ...interface{}) Fatals([]error, string, ...interface{}) Info(string, ...interface{}) KeyValue(string, string, int, ...interface{}) LineBreak() Say(string, int, ...interface{}) Table(string, [][]string) Warn(string, ...interface{}) } // ConsoleOutput implements a channel for sending messages to a user over standard output. type ConsoleOutput struct { Color bool Emoji bool Verbose bool Test bool } // Debug prints a formatted message to standard output if `Verbose` is set to `true`. Messages are // prefixed to indicate they are for debugging with :wrench: or [d]. func (c ConsoleOutput) Debug(msg string, a ...interface{}) { if c.Verbose { switch { case c.Emoji && c.Color: fmt.Printf(debug+orange+msg+reset+"\n", a...) case c.Emoji: fmt.Printf(debug+msg+"\n", a...) case c.Color: fmt.Printf("["+orange+"d"+reset+"] "+orange+msg+reset+"\n", a...) default: fmt.Printf("[d] "+msg+"\n", a...) } } } // Say prints an optionally indented, formatted message followed by a line break to standard // output. func (c ConsoleOutput) Say(msg string, indent int, a ...interface{}) { for i := 0; i < indent; i++ { fmt.Print(strings.Repeat(" ", 4)) } fmt.Printf(msg+"\n", a...) } // Info prints a formatted message to standard output. Messages are prefixed to indicate they are // informational with :information_source: or [i]. func (c ConsoleOutput) Info(msg string, a ...interface{}) { switch { case c.Emoji && c.Color: fmt.Printf(info+white+msg+reset+"\n", a...) case c.Emoji: fmt.Printf(info+msg+"\n", a...) case c.Color: fmt.Printf("["+blue+"i"+reset+"] "+white+msg+reset+"\n", a...) default: fmt.Printf("[i] "+msg+"\n", a...) } } // Warn prints a formatted message to standard output. Messages are prefixed to indicate they are // warnings with :warning: or [!]. func (c ConsoleOutput) Warn(msg string, a ...interface{}) { switch { case c.Emoji && c.Color: fmt.Printf(warning+red+msg+reset+"\n", a...) case c.Emoji: fmt.Printf(warning+msg+"\n", a...) case c.Color: fmt.Printf("["+red+"!"+reset+"] "+red+msg+reset+"\n", a...) default: fmt.Printf("[!] "+msg+"\n", a...) } } // Fatal prints a formatted message and an error string to standard output Messages are prefixed // to indicate they are fatals with :warning: or [!]. func (c ConsoleOutput) Fatal(err error, msg string, a ...interface{}) { c.Fatals([]error{err}, msg, a...) } // Fatals prints a formatted message and one or more error strings to standard output. Messages // are prefixed to indicate they are fatals with :warning: or [!]. func (c ConsoleOutput) Fatals(errs []error, msg string, a ...interface{}) { c.Warn(msg, a...) for _, err := range errs { c.Say("- "+err.Error(), 1) } if !c.Test { os.Exit(1) } } // KeyValue prints a formatted, optionally indented key and value pair to standard output. func (c ConsoleOutput) KeyValue(key, value string, indent int, a ...interface{}) { if c.Color { c.Say(white+key+reset+": "+value, indent, a...) } else { c.Say(key+": "+value, indent, a...) } } // Table prints a formatted table with optional header to standard output. func (c ConsoleOutput) Table(header string, rows [][]string) { if len(header) > 0 { if c.Color { c.Say(white+header+reset, 0) } else { c.Say(header, 0) } c.LineBreak() } w := new(tabwriter.Writer) defer w.Flush() w.Init(os.Stdout, 0, 8, 1, '\t', 0) for _, row := range rows { for i, column := range row { fmt.Fprint(w, column) if i != len(row)-1 { fmt.Fprint(w, "\t") } } fmt.Fprint(w, "\n") } } // LineBreak prints a single line break. func (c ConsoleOutput) LineBreak() { fmt.Print("\n") } ================================================ FILE: cmd/output_test.go ================================================ package cmd import "errors" var consoleOutput = ConsoleOutput{ Color: false, Emoji: false, Verbose: true, Test: true, } func ExampleConsoleOutput_Debug() { consoleOutput.Debug("PC LOAD LETTER") // Output: [d] PC LOAD LETTER } func ExampleConsoleOutput_Info() { consoleOutput.Info("Welcome! Everything is %s.", "fine") // Output: [i] Welcome! Everything is fine. } func ExampleConsoleOutput_Fatal() { err := errors.New("OXY2_TANK_EXPLOSION") consoleOutput.Fatal(err, "Houston, we've had a problem.") // Output: // [!] Houston, we've had a problem. // - OXY2_TANK_EXPLOSION } func ExampleConsoleOutput_Fatals() { errs := []error{ errors.New("OXY2_TANK_EXPLOSION"), errors.New("PRIM_FUEL_CELL_FAILURE"), errors.New("SEC_FUEL_CELL_FAILURE"), } consoleOutput.Fatals(errs, "Houston, we've had a problem.") // Output: // [!] Houston, we've had a problem. // - OXY2_TANK_EXPLOSION // - PRIM_FUEL_CELL_FAILURE // - SEC_FUEL_CELL_FAILURE } func ExampleConsoleOutput_KeyValue() { population := 468730 consoleOutput.KeyValue("Name", "Staten Island", 0) consoleOutput.KeyValue("County", "Richmond", 1) consoleOutput.KeyValue("Population", "%d", 1, population) // Output: // Name: Staten Island // County: Richmond // Population: 468730 } func ExampleConsoleOutput_Say() { username := "Werner Brandes" consoleOutput.Say("Hi, my name is %s. My voice is my passport. Verify Me.", 0, username) // Output: Hi, my name is Werner Brandes. My voice is my passport. Verify Me. } func ExampleConsoleOutput_Warn() { consoleOutput.Warn("Keep it secret, keep it safe.") // Output: [!] Keep it secret, keep it safe. } func ExampleConsoleOutput_Table() { rows := [][]string{ {"NAME", "ALLEGIANCE"}, {"Butterbumps", "House Tyrell"}, {"Jinglebell", "House Frey"}, {"Moon Boy", "House Baratheon"}, } consoleOutput.Table("Fools of Westeros", rows) // Output: // Fools of Westeros // // NAME ALLEGIANCE // Butterbumps House Tyrell // Jinglebell House Frey // Moon Boy House Baratheon } ================================================ FILE: cmd/port.go ================================================ package cmd import ( "fmt" "regexp" "strconv" "strings" ) type Port struct { Number int64 Protocol string } func (p Port) Empty() bool { return p.Number == 0 || p.Protocol == "" } func (p Port) String() string { if p.Empty() { return "" } return fmt.Sprintf("%s:%d", p.Protocol, p.Number) } var validProtocol = regexp.MustCompile("(?i)\\ATCP|HTTP(S)?\\z") func inflatePort(portExpr string) (Port, error) { switch { case portExpr == "80": return buildPort(portExpr, "HTTP") case portExpr == "443": return buildPort(portExpr, "HTTPS") case strings.Index(portExpr, ":") > 1: parts := strings.Split(portExpr, ":") protocol, number := strings.ToUpper(parts[0]), parts[1] return buildPort(number, protocol) default: return buildPort(portExpr, "TCP") } } func buildPort(inputNumber, inputProtocol string) (Port, error) { number, err := strconv.ParseInt(inputNumber, 10, 64) if err != nil { if _, ok := err.(*strconv.NumError); ok { return Port{}, fmt.Errorf("could not parse port number from %s", inputNumber) } else { return Port{}, err } } return Port{number, inputProtocol}, nil } func inflatePorts(portExprs []string) ([]Port, []error) { var ports []Port var errs []error for _, portExpr := range portExprs { if port, err := inflatePort(portExpr); err == nil { ports = append(ports, port) } else { errs = append(errs, err) } } return ports, errs } func validatePort(port Port) (errs []error) { if !validProtocol.MatchString(port.Protocol) { errs = append(errs, fmt.Errorf("invalid protocol %s (specify TCP, HTTP, or HTTPS)", port.Protocol)) } if port.Number < 1 || port.Number > 65535 { errs = append(errs, fmt.Errorf("invalid port %d (specify within 1 - 65535)", port.Number)) } return } ================================================ FILE: cmd/port_test.go ================================================ package cmd import ( "testing" ) func TestEmpty(t *testing.T) { var tests = []struct { port Port empty bool }{ {Port{}, true}, {Port{80, ""}, true}, {Port{0, "HTTP"}, true}, {Port{80, "HTTP"}, false}, } for _, test := range tests { if test.port.Empty() != test.empty { t.Errorf("expected port %s empty == %t, got %t", test.port, test.empty, test.port.Empty()) } } } func TestString(t *testing.T) { var tests = []struct { port Port out string }{ {Port{}, ""}, {Port{80, ""}, ""}, {Port{0, "HTTP"}, ""}, {Port{80, "HTTP"}, "HTTP:80"}, {Port{25, "TCP"}, "TCP:25"}, } for _, test := range tests { if test.port.String() != test.out { t.Errorf("expected port %s == %s, got %s", test.port, test.out, test.port.String()) } } } ================================================ FILE: cmd/root.go ================================================ package cmd import ( "fmt" "os" "runtime" "strconv" "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" "github.com/aws/aws-sdk-go/aws/session" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" "golang.org/x/crypto/ssh/terminal" ) const ( version = "0.3.2" defaultClusterName = "fargate" defaultRegion = "us-east-1" mebibytesInGibibyte = 1024 protocolHttp = "HTTP" protocolHttps = "HTTPS" protocolTcp = "TCP" runtimeMacOS = "darwin" typeApplication = "application" typeNetwork = "network" validRuleTypesPattern = "(?i)^host|path$" describeRequestLimitRate = 10 ) var InvalidCpuAndMemoryCombination = fmt.Errorf(`Invalid CPU and Memory settings CPU (CPU Units) Memory (MiB) --------------- ------------ 256 512, 1024, or 2048 512 1024 through 4096 in 1GiB increments 1024 2048 through 8192 in 1GiB increments 2048 4096 through 16384 in 1GiB increments 4096 8192 through 30720 in 1GiB increments `) var ( clusterName string noColor bool noEmoji bool output ConsoleOutput region string sess *session.Session verbose bool ) var rootCmd = &cobra.Command{ Use: "fargate", Short: "Deploy serverless containers onto the cloud from your command line", Long: `Deploy serverless containers onto the cloud from your command line fargate is a command-line interface to deploy containers to AWS Fargate that makes it easy to run containers in AWS as one-off tasks or managed, highly available services secured by free TLS certificates. It bundles the power of AWS including Amazon Elastic Container Service (ECS), Amazon Elastic Container Registry (ECR), Elastic Load Balancing, AWS Certificate Manager, Amazon CloudWatch Logs, and Amazon Route 53 into an easy-to-use CLI.`, PersistentPreRun: func(cmd *cobra.Command, args []string) { output = ConsoleOutput{} if cmd.Parent().Name() == "fargate" { return } if verbose { verbose = true console.Verbose = true output.Verbose = true } if terminal.IsTerminal(int(os.Stdout.Fd())) { if !noColor { console.Color = true output.Color = true } if runtime.GOOS == runtimeMacOS && !noEmoji { output.Emoji = true } } envAwsDefaultRegion := os.Getenv("AWS_DEFAULT_REGION") envAwsRegion := os.Getenv("AWS_REGION") if region == "" { if envAwsDefaultRegion != "" { region = envAwsDefaultRegion } else if envAwsRegion != "" { region = envAwsRegion } else { if sess = session.Must(session.NewSession()); *sess.Config.Region != "" { region = *sess.Config.Region } else { region = defaultRegion } } } config := &aws.Config{ Region: aws.String(region), } if verbose { config.LogLevel = aws.LogLevel(aws.LogDebugWithHTTPBody) } sess = session.Must( session.NewSession(config), ) _, err := sess.Config.Credentials.Get() if aerr, ok := err.(awserr.Error); ok { switch aerr.Code() { case "NoCredentialProviders": console.Issue("Could not find your AWS credentials") console.Info("Your AWS credentials could not be found. Please configure your environment with your access key") console.Info(" ID and secret access key using either the shared configuration file or environment variables.") console.Info(" See http://docs.aws.amazon.com/sdk-for-go/v1/developer-guide/configuring-sdk.html#specifying-credentials") console.Info(" for more details.") console.Exit(1) default: console.ErrorExit(err, "Could not create create AWS session") } } if clusterName == "" { clusterName = defaultClusterName ecs := ECS.New(sess, clusterName) output.Debug("Creating default cluster [API=ecs Action=CreateCluster]") arn, err := ecs.CreateCluster() if err == nil { output.Debug("Created default cluster [ARN=%s]", arn) } else { output.Fatal(err, "Could not create default cluster") } } }, } func Execute() { rootCmd.Version = version rootCmd.Execute() } func init() { rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Verbose output") rootCmd.PersistentFlags().StringVar(®ion, "region", "", `AWS region (default "us-east-1")`) rootCmd.PersistentFlags().BoolVar(&noColor, "no-color", false, "Disable color output") rootCmd.PersistentFlags().StringVar(&clusterName, "cluster", "", `ECS cluster name (default "fargate")`) if runtime.GOOS == runtimeMacOS { rootCmd.PersistentFlags().BoolVar(&noEmoji, "no-emoji", false, "Disable emoji output") } } func extractEnvVars(inputEnvVars []string) []ECS.EnvVar { var envVars []ECS.EnvVar if len(inputEnvVars) == 0 { return envVars } for _, inputEnvVar := range inputEnvVars { splitInputEnvVar := strings.SplitN(inputEnvVar, "=", 2) if len(splitInputEnvVar) != 2 { console.ErrorExit(fmt.Errorf("%s must be in the form of KEY=value", inputEnvVar), "Invalid environment variable") } envVar := ECS.EnvVar{ Key: strings.ToUpper(splitInputEnvVar[0]), Value: splitInputEnvVar[1], } envVars = append(envVars, envVar) } return envVars } func validateCpuAndMemory(inputCpuUnits, inputMebibytes string) error { cpuUnits, err := strconv.ParseInt(inputCpuUnits, 10, 16) if err != nil { return err } mebibytes, err := strconv.ParseInt(inputMebibytes, 10, 16) if err != nil { return err } switch cpuUnits { case 256: if mebibytes == 512 || validateMebibytes(mebibytes, 1024, 2048) { return nil } case 512: if validateMebibytes(mebibytes, 1024, 4096) { return nil } case 1024: if validateMebibytes(mebibytes, 2048, 8192) { return nil } case 2048: if validateMebibytes(mebibytes, 4096, 16384) { return nil } case 4096: if validateMebibytes(mebibytes, 8192, 30720) { return nil } } return InvalidCpuAndMemoryCombination } func validateMebibytes(mebibytes, min, max int64) bool { return mebibytes >= min && mebibytes <= max && mebibytes%mebibytesInGibibyte == 0 } ================================================ FILE: cmd/root_test.go ================================================ package cmd import "testing" var validateCpuAndMemoryTests = []struct { CpuUnits string Mebibytes string Out error }{ // 0.25 vCpu {"256", "512", nil}, {"256", "1024", nil}, {"256", "2048", nil}, {"256", "0", InvalidCpuAndMemoryCombination}, {"256", "768", InvalidCpuAndMemoryCombination}, {"256", "2151", InvalidCpuAndMemoryCombination}, {"256", "3072", InvalidCpuAndMemoryCombination}, // 0.5 vCpu {"512", "1024", nil}, {"512", "2048", nil}, {"512", "3072", nil}, {"512", "4096", nil}, {"512", "512", InvalidCpuAndMemoryCombination}, // 1 vCpu {"1024", "2048", nil}, {"1024", "5120", nil}, {"1024", "8192", nil}, {"1024", "1024", InvalidCpuAndMemoryCombination}, {"1024", "9216", InvalidCpuAndMemoryCombination}, // 2 vCpu {"2048", "4096", nil}, {"2048", "10240", nil}, {"2048", "16384", nil}, {"2048", "3072", InvalidCpuAndMemoryCombination}, {"2048", "17408", InvalidCpuAndMemoryCombination}, // 4 vCpu {"4096", "8192", nil}, {"4096", "15360", nil}, {"4096", "30720", nil}, {"4096", "1024", InvalidCpuAndMemoryCombination}, {"4096", "31744", InvalidCpuAndMemoryCombination}, } func TestValidateCpuAndMemoryWithValidParameters(t *testing.T) { err := validateCpuAndMemory("256", "512") if err != nil { t.Errorf("Validation failed, got %s, want nil", err) } } func TestValidateCpuAndMemoryWithInvalidParameters(t *testing.T) { err := validateCpuAndMemory("5", "23849") if err == nil { t.Errorf("Validation failed, got nil, want %s", InvalidCpuAndMemoryCombination) } } func TestValidateCpuAndMemory(t *testing.T) { for _, test := range validateCpuAndMemoryTests { s := validateCpuAndMemory(test.CpuUnits, test.Mebibytes) if s != test.Out { t.Errorf("validateCpuAndMemory(%s, %s) => %#v, want %s", test.CpuUnits, test.Mebibytes, s, test.Out) } } } ================================================ FILE: cmd/service.go ================================================ package cmd import ( "github.com/spf13/cobra" ) const serviceLogGroupFormat = "/fargate/service/%s" var serviceCmd = &cobra.Command{ Use: "service", Short: "Manage services", Long: `Manage services Services manage long-lived instances of your containers that are run on AWS Fargate. If your container exits for any reason, the service scheduler will restart your containers and ensure your service has the desired number of tasks running. Services can be used in concert with a load balancer to distribute traffic amongst the tasks in your service.`, } func init() { rootCmd.AddCommand(serviceCmd) } ================================================ FILE: cmd/service_create.go ================================================ package cmd import ( "fmt" "regexp" "strings" CWL "github.com/awslabs/fargatecli/cloudwatchlogs" "github.com/awslabs/fargatecli/console" "github.com/awslabs/fargatecli/docker" EC2 "github.com/awslabs/fargatecli/ec2" ECR "github.com/awslabs/fargatecli/ecr" ECS "github.com/awslabs/fargatecli/ecs" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/awslabs/fargatecli/git" IAM "github.com/awslabs/fargatecli/iam" "github.com/spf13/cobra" ) const typeService = "service" type ServiceCreateOperation struct { Cpu string EnvVars []ECS.EnvVar Image string LoadBalancerArn string LoadBalancerName string Memory string Num int64 Port Port Rules []ELBV2.Rule SecurityGroupIds []string ServiceName string SubnetIds []string TaskRole string TaskCommand []string AssignPublicIPEnabled bool } func (o *ServiceCreateOperation) SetPort(inputPort string) { var msgs []string port, _ := inflatePort(inputPort) if !validProtocol.MatchString(port.Protocol) { msgs = append(msgs, fmt.Sprintf("Invalid protocol %s [specify TCP, HTTP, or HTTPS]", port.Protocol)) } if port.Number < 1 || port.Number > 65535 { msgs = append(msgs, fmt.Sprintf("Invalid port %d [specify within 1 - 65535]", port.Number)) } if len(msgs) > 0 { console.ErrorExit(fmt.Errorf(strings.Join(msgs, ", ")), "Invalid command line flags") } o.Port = port } func (o *ServiceCreateOperation) Validate() { err := validateCpuAndMemory(o.Cpu, o.Memory) if err != nil { console.ErrorExit(err, "Invalid settings: %s CPU units / %s MiB", o.Cpu, o.Memory) } if o.Num < 1 { console.ErrorExit(err, "Invalid number of tasks to keep running: %d, num must be > 1", o.Num) } } func (o *ServiceCreateOperation) SetLoadBalancer(lb string) { if o.Port.Empty() { console.IssueExit("Setting a load balancer requires a port") } elbv2 := ELBV2.New(sess) loadBalancer := elbv2.DescribeLoadBalancer(lb) if loadBalancer.Type == typeNetwork { if o.Port.Protocol != protocolTcp { console.ErrorExit(fmt.Errorf("network load balancer %s only supports TCP", lb), "Invalid load balancer and protocol") } } if loadBalancer.Type == typeApplication { if !(o.Port.Protocol == protocolHttp || o.Port.Protocol == protocolHttps) { console.ErrorExit(fmt.Errorf("application load balancer %s only supports HTTP or HTTPS", lb), "Invalid load balancer and protocol") } } o.LoadBalancerName = lb o.LoadBalancerArn = loadBalancer.ARN } func (o *ServiceCreateOperation) SetRules(inputRules []string) { var rules []ELBV2.Rule var msgs []string validRuleTypes := regexp.MustCompile(validRuleTypesPattern) if len(inputRules) > 0 && o.LoadBalancerArn == "" { msgs = append(msgs, "lb must be configured if rules are specified") } for _, inputRule := range inputRules { splitInputRule := strings.SplitN(inputRule, "=", 2) if len(splitInputRule) != 2 { msgs = append(msgs, "rules must be in the form of type=value") } if !validRuleTypes.MatchString(splitInputRule[0]) { msgs = append(msgs, fmt.Sprintf("Invalid rule type %s [must be path or host]", splitInputRule[0])) } rules = append(rules, ELBV2.Rule{ Type: strings.ToUpper(splitInputRule[0]), Value: splitInputRule[1], }, ) } if len(msgs) > 0 { console.ErrorExit(fmt.Errorf(strings.Join(msgs, ", ")), "Invalid rule") } o.Rules = rules } func (o *ServiceCreateOperation) SetEnvVars(inputEnvVars []string) { o.EnvVars = extractEnvVars(inputEnvVars) } func (o *ServiceCreateOperation) SetSecurityGroupIds(securityGroupIds []string) { o.SecurityGroupIds = securityGroupIds } var ( flagServiceCreateCpu string flagServiceCreateEnvVars []string flagServiceCreateImage string flagServiceCreateLb string flagServiceCreateMemory string flagServiceCreateNum int64 flagServiceCreatePort string flagServiceCreateRules []string flagServiceCreateSecurityGroupIds []string flagServiceCreateSubnetIds []string flagServiceCreateTaskRole string flagServiceCreateTaskCommand []string flagServiceAssignPublicIP bool ) var serviceCreateCmd = &cobra.Command{ Use: "create ", Short: "Create a service", Long: `Create a service CPU and memory settings can be optionally specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | If not specified, fargate will launch minimally sized tasks at 0.25 vCPU (256 CPU units) and 0.5GB (512 MiB) of memory. The Docker container image to use in the service can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used. To use the service with a load balancer, a port must be specified when the service is created. Specify a port by passing the --port flag and a port expression of protocol:port-number. For example, if the service listens on port 80 and uses HTTP, specify HTTP:80. Valid protocols are HTTP, HTTPS, and TCP. You can only specify a single port. Services can optionally be configured to use a load balancer. To put a load balancer in front a service, pass the --lb flag with the name of a load balancer. If you specify a load balancer, you must also specify a port via the --port flag to which the load balancer should forward requests. Optionally, Application Load Balancers can be configured to route HTTP/HTTPS traffic to the service based upon a rule. Rules are configured by passing one or more rules by specifying the --rule flag along with a rule expression. Rule expressions are in the format of TYPE=VALUE. Type can either be PATH or HOST. PATH matches the PATH of the request and HOST matches the requested hostname in the HTTP request. Both PATH and HOST types can include up to three wildcard characters: * to match multiple characters and ? to match a single character. If rules are omitted, the service will be the load balancer's default action. Environment variables can be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables. Specify the desired count of tasks the service should maintain by passing the --num flag with a number. If you omit this flag, fargate will configure a service with a desired number of tasks of 1. Security groups can optionally be specified for the service by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the service. By default, the service will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. A task role can be optionally specified via the --task-role flag by providing eith a full IAM role ARN or the name of an IAM role. The tasks run by the service will be able to assume this role. The default command of the docker image can be overridden using the --task-command flag, where the value is a string of comma seperated values representing the command. These values will be placed into an array as per the requirements of the docker CMD syntax Services can be configured to have only private ip address via the --assign-public-ip=false flag.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceCreateOperation{ Cpu: flagServiceCreateCpu, Image: flagServiceCreateImage, Memory: flagServiceCreateMemory, Num: flagServiceCreateNum, SecurityGroupIds: flagServiceCreateSecurityGroupIds, ServiceName: args[0], SubnetIds: flagServiceCreateSubnetIds, TaskRole: flagServiceCreateTaskRole, TaskCommand: flagServiceCreateTaskCommand, AssignPublicIPEnabled: flagServiceAssignPublicIP, } if flagServiceCreatePort != "" { operation.SetPort(flagServiceCreatePort) } if flagServiceCreateLb != "" { operation.SetLoadBalancer(flagServiceCreateLb) } if len(flagServiceCreateRules) > 0 { operation.SetRules(flagServiceCreateRules) } if len(flagServiceCreateEnvVars) > 0 { operation.SetEnvVars(flagServiceCreateEnvVars) } operation.Validate() createService(operation) }, } func init() { serviceCreateCmd.Flags().StringVarP(&flagServiceCreateCpu, "cpu", "c", "256", "Amount of cpu units to allocate for each task") serviceCreateCmd.Flags().StringVarP(&flagServiceCreateMemory, "memory", "m", "512", "Amount of MiB to allocate for each task") serviceCreateCmd.Flags().StringSliceVarP(&flagServiceCreateEnvVars, "env", "e", []string{}, "Environment variables to set [e.g. KEY=value] (can be specified multiple times)") serviceCreateCmd.Flags().StringVarP(&flagServiceCreatePort, "port", "p", "", "Port to listen on [e.g., 80, 443, http:8080, https:8443, tcp:1935]") serviceCreateCmd.Flags().StringVarP(&flagServiceCreateImage, "image", "i", "", "Docker image to run in the service; if omitted Fargate will build an image from the Dockerfile in the current directory") serviceCreateCmd.Flags().StringVarP(&flagServiceCreateLb, "lb", "l", "", "Name of a load balancer to use") serviceCreateCmd.Flags().StringSliceVarP(&flagServiceCreateRules, "rule", "r", []string{}, "Routing rule for the load balancer [e.g. host=api.example.com, path=/api/*]; if omitted service will be the default route (can be specified multiple times)") serviceCreateCmd.Flags().Int64VarP(&flagServiceCreateNum, "num", "n", 1, "Number of tasks instances to keep running") serviceCreateCmd.Flags().StringSliceVar(&flagServiceCreateSecurityGroupIds, "security-group-id", []string{}, "ID of a security group to apply to the service (can be specified multiple times)") serviceCreateCmd.Flags().StringSliceVar(&flagServiceCreateSubnetIds, "subnet-id", []string{}, "ID of a subnet in which to place the service (can be specified multiple times)") serviceCreateCmd.Flags().StringVarP(&flagServiceCreateTaskRole, "task-role", "", "", "Name or ARN of an IAM role that the service's tasks can assume") serviceCreateCmd.Flags().StringSliceVar(&flagServiceCreateTaskCommand, "task-command", []string{}, "Command to run inside container instead of the one specified in the docker image") serviceCreateCmd.Flags().BoolVarP(&flagServiceAssignPublicIP, "assign-public-ip", "", true, "Assign public ip address") serviceCmd.AddCommand(serviceCreateCmd) } func createService(operation *ServiceCreateOperation) { var targetGroupArn string cwl := CWL.New(sess) ec2 := EC2.New(sess) ecr := ECR.New(sess) elbv2 := ELBV2.New(sess) ecs := ECS.New(sess, clusterName) iam := IAM.New(sess) ecsTaskExecutionRoleArn := iam.CreateEcsTaskExecutionRole() logGroupName := cwl.CreateLogGroup(serviceLogGroupFormat, operation.ServiceName) if len(operation.SecurityGroupIds) == 0 { defaultSecurityGroupID, _ := ec2.GetDefaultSecurityGroupID() operation.SecurityGroupIds = []string{defaultSecurityGroupID} } if len(operation.SubnetIds) == 0 { operation.SubnetIds, _ = ec2.GetDefaultSubnetIDs() } if operation.Image == "" { var tag, repositoryUri string if ecr.IsRepositoryCreated(operation.ServiceName) { repositoryUri = ecr.GetRepositoryUri(operation.ServiceName) } else { repositoryUri = ecr.CreateRepository(operation.ServiceName) } if git.IsCwdGitRepo() { tag = git.GetShortSha() } else { tag = docker.GenerateTag() } repository := docker.NewRepository(repositoryUri) username, password := ecr.GetUsernameAndPassword() repository.Login(username, password) repository.Build(tag) repository.Push(tag) operation.Image = repository.UriFor(tag) } if operation.LoadBalancerArn != "" { vpcId, _ := ec2.GetSubnetVPCID(operation.SubnetIds[0]) targetGroupArn, _ = elbv2.CreateTargetGroup( ELBV2.CreateTargetGroupParameters{ Name: fmt.Sprintf("%s-%s", clusterName, operation.ServiceName), Port: operation.Port.Number, Protocol: operation.Port.Protocol, VPCID: vpcId, }, ) if len(operation.Rules) > 0 { for _, rule := range operation.Rules { elbv2.AddRule(operation.LoadBalancerArn, targetGroupArn, rule) } } else { elbv2.ModifyLoadBalancerDefaultAction(operation.LoadBalancerArn, targetGroupArn) } } taskDefinitionArn := ecs.CreateTaskDefinition( &ECS.CreateTaskDefinitionInput{ Cpu: operation.Cpu, EnvVars: operation.EnvVars, ExecutionRoleArn: ecsTaskExecutionRoleArn, Image: operation.Image, Memory: operation.Memory, Name: operation.ServiceName, Port: operation.Port.Number, LogGroupName: logGroupName, LogRegion: region, TaskRole: operation.TaskRole, Type: typeService, TaskCommand: operation.TaskCommand, }, ) ecs.CreateService( &ECS.CreateServiceInput{ Cluster: clusterName, DesiredCount: operation.Num, Name: operation.ServiceName, Port: operation.Port.Number, SecurityGroupIds: operation.SecurityGroupIds, SubnetIds: operation.SubnetIds, TargetGroupArn: targetGroupArn, TaskDefinitionArn: taskDefinitionArn, AssignPublicIpEnabled: operation.AssignPublicIPEnabled, }, ) console.Info("Created service %s", operation.ServiceName) } ================================================ FILE: cmd/service_deploy.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/console" "github.com/awslabs/fargatecli/docker" ECR "github.com/awslabs/fargatecli/ecr" ECS "github.com/awslabs/fargatecli/ecs" "github.com/awslabs/fargatecli/git" "github.com/spf13/cobra" ) type ServiceDeployOperation struct { ServiceName string Image string } var flagServiceDeployImage string var serviceDeployCmd = &cobra.Command{ Use: "deploy ", Short: "Deploy new image to service", Long: `Deploy new image to service The Docker container image to use in the service can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceDeployOperation{ ServiceName: args[0], Image: flagServiceDeployImage, } deployService(operation) }, } func init() { serviceDeployCmd.Flags().StringVarP(&flagServiceDeployImage, "image", "i", "", "Docker image to run in the service; if omitted Fargate will build an image from the Dockerfile in the current directory") serviceCmd.AddCommand(serviceDeployCmd) } func deployService(operation *ServiceDeployOperation) { ecs := ECS.New(sess, clusterName) service := ecs.DescribeService(operation.ServiceName) if operation.Image == "" { var tag string ecr := ECR.New(sess) repositoryUri := ecr.GetRepositoryUri(operation.ServiceName) repository := docker.Repository{Uri: repositoryUri} username, password := ecr.GetUsernameAndPassword() if git.IsCwdGitRepo() { tag = git.GetShortSha() } else { tag = docker.GenerateTag() } repository.Login(username, password) repository.Build(tag) repository.Push(tag) operation.Image = repository.UriFor(tag) } taskDefinitionArn := ecs.UpdateTaskDefinitionImage(service.TaskDefinitionArn, operation.Image) ecs.UpdateServiceTaskDefinition(operation.ServiceName, taskDefinitionArn) console.Info("Deployed %s to service %s", operation.Image, operation.ServiceName) } ================================================ FILE: cmd/service_destroy.go ================================================ package cmd import ( "fmt" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) type ServiceDestroyOperation struct { ServiceName string } var serviceDestroyCmd = &cobra.Command{ Use: "destroy ", Short: "Destroy a service", Long: `Destroy service In order to destroy a service, it must first be scaled to 0 running tasks.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceDestroyOperation{ ServiceName: args[0], } destroyService(operation) }, } func init() { serviceCmd.AddCommand(serviceDestroyCmd) } func destroyService(operation *ServiceDestroyOperation) { elbv2 := ELBV2.New(sess) ecs := ECS.New(sess, clusterName) service := ecs.DescribeService(operation.ServiceName) if service.DesiredCount > 0 { err := fmt.Errorf("%d tasks running, scale service to 0", service.DesiredCount) console.ErrorExit(err, "Cannot destroy service %s", operation.ServiceName) } if service.TargetGroupArn != "" { loadBalancerArn := elbv2.GetTargetGroupLoadBalancerArn(service.TargetGroupArn) loadBalancer := elbv2.DescribeLoadBalancerByARN(loadBalancerArn) listeners := elbv2.GetListeners(loadBalancerArn) for _, listener := range listeners { for _, rule := range elbv2.DescribeRules(listener.ARN) { if rule.TargetGroupARN == service.TargetGroupArn { if rule.IsDefault { defaultTargetGroupName := fmt.Sprintf(defaultTargetGroupFormat, loadBalancer.Name) defaultTargetGroupArn := elbv2.GetTargetGroupArn(defaultTargetGroupName) if defaultTargetGroupArn == "" { defaultTargetGroupArn, _ = elbv2.CreateTargetGroup( ELBV2.CreateTargetGroupParameters{ Name: defaultTargetGroupName, Port: listeners[0].Port, Protocol: listeners[0].Protocol, VPCID: loadBalancer.VPCID, }, ) } elbv2.ModifyListenerDefaultAction(listener.ARN, defaultTargetGroupArn) } else { elbv2.DeleteRule(rule.ARN) } } } } elbv2.DeleteTargetGroupByArn(service.TargetGroupArn) } ecs.DestroyService(operation.ServiceName) console.Info("Destroyed service %s", operation.ServiceName) } ================================================ FILE: cmd/service_env.go ================================================ package cmd import ( "github.com/spf13/cobra" ) var serviceEnvCmd = &cobra.Command{ Use: "env", Short: "Manage environment variables", } func init() { serviceCmd.AddCommand(serviceEnvCmd) } ================================================ FILE: cmd/service_env_list.go ================================================ package cmd import ( "fmt" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceEnvListOperation struct { ServiceName string } var serviceEnvListCmd = &cobra.Command{ Use: "list ", Short: "Show environment variables", Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceEnvListOperation{ ServiceName: args[0], } serviceEnvList(operation) }, } func init() { serviceEnvCmd.AddCommand(serviceEnvListCmd) } func serviceEnvList(operation *ServiceEnvListOperation) { ecs := ECS.New(sess, clusterName) service := ecs.DescribeService(operation.ServiceName) envVars := ecs.GetEnvVarsFromTaskDefinition(service.TaskDefinitionArn) for _, envVar := range envVars { fmt.Printf("%s=%s\n", envVar.Key, envVar.Value) } } ================================================ FILE: cmd/service_env_set.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceEnvSetOperation struct { ServiceName string EnvVars []ECS.EnvVar } func (o *ServiceEnvSetOperation) Validate() { if len(o.EnvVars) == 0 { console.IssueExit("No environment variables specified") } } func (o *ServiceEnvSetOperation) SetEnvVars(inputEnvVars []string) { o.EnvVars = extractEnvVars(inputEnvVars) } var flagServiceEnvSetEnvVars []string var serviceEnvSetCmd = &cobra.Command{ Use: "set --env [--env ] ...", Short: "Set environment variables", Long: `Set environment variables At least one environment variable must be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceEnvSetOperation{ ServiceName: args[0], } operation.SetEnvVars(flagServiceEnvSetEnvVars) operation.Validate() serviceEnvSet(operation) }, } func init() { serviceEnvSetCmd.Flags().StringArrayVarP(&flagServiceEnvSetEnvVars, "env", "e", []string{}, "Environment variables to set [e.g. KEY=value]") serviceEnvCmd.AddCommand(serviceEnvSetCmd) } func serviceEnvSet(operation *ServiceEnvSetOperation) { ecs := ECS.New(sess, clusterName) service := ecs.DescribeService(operation.ServiceName) taskDefinitionArn := ecs.AddEnvVarsToTaskDefinition(service.TaskDefinitionArn, operation.EnvVars) ecs.UpdateServiceTaskDefinition(operation.ServiceName, taskDefinitionArn) console.Info("Set %s environment variables:", operation.ServiceName) for _, envVar := range operation.EnvVars { console.Info("- %s=%s", envVar.Key, envVar.Value) } } ================================================ FILE: cmd/service_env_unset.go ================================================ package cmd import ( "strings" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceEnvUnsetOperation struct { ServiceName string Keys []string } func (o *ServiceEnvUnsetOperation) Validate() { if len(o.Keys) == 0 { console.IssueExit("No keys specified") } } func (o *ServiceEnvUnsetOperation) SetKeys(keys []string) { o.Keys = Map(keys, strings.ToUpper) } var serviceEnvUnsetCmd = &cobra.Command{ Use: "unset --key [--key ] ...", Short: "Unset environment variables", Long: `Unset environment variables Unsets the environment variable specified via the --key flag. Specify --key with a key name multiple times to unset multiple variables.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceEnvUnsetOperation{ ServiceName: args[0], } operation.SetKeys(flagServiceEnvUnsetKeys) operation.Validate() serviceEnvUnset(operation) }, } var flagServiceEnvUnsetKeys []string func init() { serviceEnvUnsetCmd.Flags().StringSliceVarP(&flagServiceEnvUnsetKeys, "key", "k", []string{}, "Environment variable keys to unset [e.g. KEY, NGINX_PORT]") serviceEnvCmd.AddCommand(serviceEnvUnsetCmd) } func serviceEnvUnset(operation *ServiceEnvUnsetOperation) { ecs := ECS.New(sess, clusterName) service := ecs.DescribeService(operation.ServiceName) taskDefinitionArn := ecs.RemoveEnvVarsFromTaskDefinition(service.TaskDefinitionArn, operation.Keys) ecs.UpdateServiceTaskDefinition(operation.ServiceName, taskDefinitionArn) console.Info("Unset %s environment variables:", operation.ServiceName) for _, key := range operation.Keys { console.Info("- %s", key) } } ================================================ FILE: cmd/service_info.go ================================================ package cmd import ( "fmt" "os" "sort" "strings" "text/tabwriter" ACM "github.com/awslabs/fargatecli/acm" "github.com/awslabs/fargatecli/console" EC2 "github.com/awslabs/fargatecli/ec2" ECS "github.com/awslabs/fargatecli/ecs" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) const statusActive = "ACTIVE" type ServiceInfoOperation struct { ServiceName string } var serviceInfoCmd = &cobra.Command{ Use: "info ", Short: "Inspect service", Long: `Inspect service Show extended information for a service including load balancer configuration, active deployments, and environment variables. Deployments show active versions of your service that are running. Multiple deployments are shown if a service is transitioning due to a deployment or update to configuration such a CPU, memory, or environment variables.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceInfoOperation{ ServiceName: args[0], } getServiceInfo(operation) }, } func init() { serviceCmd.AddCommand(serviceInfoCmd) } func getServiceInfo(operation *ServiceInfoOperation) { var eniIds []string acm := ACM.New(sess) ecs := ECS.New(sess, clusterName) ec2 := EC2.New(sess) elbv2 := ELBV2.New(sess) service := ecs.DescribeService(operation.ServiceName) tasks := ecs.DescribeTasksForService(operation.ServiceName) if service.Status != statusActive { console.InfoExit("Service not found") } console.KeyValue("Service Name", "%s\n", operation.ServiceName) console.KeyValue("Status", "\n") console.KeyValue(" Desired", "%d\n", service.DesiredCount) console.KeyValue(" Running", "%d\n", service.RunningCount) console.KeyValue(" Pending", "%d\n", service.PendingCount) console.KeyValue("Image", "%s\n", service.Image) console.KeyValue("Cpu", "%s\n", service.Cpu) console.KeyValue("Memory", "%s\n", service.Memory) if service.TaskRole != "" { console.KeyValue("Task Role", "%s\n", service.TaskRole) } console.KeyValue("Subnets", "%s\n", strings.Join(service.SubnetIds, ", ")) console.KeyValue("Security Groups", "%s\n", strings.Join(service.SecurityGroupIds, ", ")) if service.TargetGroupArn != "" { if loadBalancerArn := elbv2.GetTargetGroupLoadBalancerArn(service.TargetGroupArn); loadBalancerArn != "" { loadBalancer := elbv2.DescribeLoadBalancerByARN(loadBalancerArn) listeners := elbv2.GetListeners(loadBalancerArn) console.KeyValue("Load Balancer", "\n") console.KeyValue(" Name", "%s\n", loadBalancer.Name) console.KeyValue(" DNS Name", "%s\n", loadBalancer.DNSName) if len(listeners) > 0 { console.KeyValue(" Ports", "\n") } for _, listener := range listeners { var ruleOutput []string rules := elbv2.DescribeRules(listener.ARN) sort.Slice(rules, func(i, j int) bool { return rules[i].Priority > rules[j].Priority }) for _, rule := range rules { if rule.TargetGroupARN == service.TargetGroupArn { ruleOutput = append(ruleOutput, rule.String()) } } console.KeyValue(" "+listener.String(), "\n") console.KeyValue(" Rules", "%s\n", strings.Join(ruleOutput, ", ")) if len(listener.CertificateARNs) > 0 { certificateDomains := acm.ListCertificateDomainNames(listener.CertificateARNs) console.KeyValue(" Certificates", "%s\n", strings.Join(certificateDomains, ", ")) } } } if len(service.EnvVars) > 0 { console.KeyValue("Environment Variables", "\n") for _, envVar := range service.EnvVars { fmt.Printf(" %s=%s\n", envVar.Key, envVar.Value) } } } if len(tasks) > 0 { console.Header("Tasks") for _, task := range tasks { if task.EniId != "" { eniIds = append(eniIds, task.EniId) } } enis := ec2.DescribeNetworkInterfaces(eniIds) w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "ID\tIMAGE\tSTATUS\tRUNNING\tIP\tCPU\tMEMORY\tDEPLOYMENT\t") for _, t := range tasks { fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n", t.TaskId, t.Image, Humanize(t.LastStatus), t.RunningFor(), enis[t.EniId].PublicIpAddress, t.Cpu, t.Memory, t.DeploymentId, ) } w.Flush() } if len(service.Deployments) > 0 { console.Header("Deployments") w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "ID\tIMAGE\tSTATUS\tCREATED\tDESIRED\tRUNNING\tPENDING") for _, d := range service.Deployments { fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%d\t%d\t%d\n", d.Id, d.Image, Humanize(d.Status), d.CreatedAt, d.DesiredCount, d.RunningCount, d.PendingCount, ) } w.Flush() } if len(service.Events) > 0 { console.Header("Events") for i, event := range service.Events { fmt.Printf("[%s] %s\n", event.CreatedAt, event.Message) if i == 10 && !verbose { break } } } } ================================================ FILE: cmd/service_list.go ================================================ package cmd import ( "fmt" "os" "text/tabwriter" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" ELBV2 "github.com/awslabs/fargatecli/elbv2" "github.com/spf13/cobra" ) var serviceListCmd = &cobra.Command{ Use: "list", Short: "List services", Run: func(cmd *cobra.Command, args []string) { listServices() }, } func init() { serviceCmd.AddCommand(serviceListCmd) } func listServices() { var targetGroupArns []string var loadBalancerArns []string targetGroups := make(map[string]ELBV2.TargetGroup) loadBalancers := make(map[string]ELBV2.LoadBalancer) ecs := ECS.New(sess, clusterName) elbv2 := ELBV2.New(sess) services := ecs.ListServices() for _, service := range services { if service.TargetGroupArn != "" { targetGroupArns = append(targetGroupArns, service.TargetGroupArn) } } if len(targetGroupArns) > 0 { for _, targetGroup := range elbv2.DescribeTargetGroups(targetGroupArns) { targetGroups[targetGroup.Arn] = targetGroup if targetGroup.LoadBalancerARN != "" { loadBalancerArns = append(loadBalancerArns, targetGroup.LoadBalancerARN) } } } if len(loadBalancerArns) > 0 { lbs, _ := elbv2.DescribeLoadBalancersByARN(loadBalancerArns) for _, loadBalancer := range lbs { loadBalancers[loadBalancer.ARN] = loadBalancer } } if len(services) > 0 { w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "NAME\tIMAGE\tCPU\tMEMORY\tLOAD BALANCER\tDESIRED\tRUNNING\tPENDING\t") for _, service := range services { var loadBalancer string if service.TargetGroupArn != "" { tg := targetGroups[service.TargetGroupArn] lb := loadBalancers[tg.LoadBalancerARN] loadBalancer = lb.Name } fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%d\t%d\t%d\t\n", service.Name, service.Image, service.Cpu, service.Memory, loadBalancer, service.DesiredCount, service.RunningCount, service.PendingCount, ) } w.Flush() } else { console.Info("No services found") } } ================================================ FILE: cmd/service_logs.go ================================================ package cmd import ( "fmt" "github.com/spf13/cobra" ) var ( flagServiceLogsFilter string flagServiceLogsEndTime string flagServiceLogsStartTime string flagServiceLogsFollow bool flagServiceLogsTasks []string ) var serviceLogsCmd = &cobra.Command{ Use: "logs ", Short: "Show logs from tasks in a service", Long: `Show logs from tasks in a service Return either a specific segment of service logs or tail logs in real-time using the --follow option. Logs are prefixed by their log stream name which is in the format of "fargate/\/\." Follow will continue to run and return logs until interrupted by Control-C. If --follow is passed --end cannot be specified. Logs can be returned for specific tasks within a service by passing a task ID via the --task flag. Pass --task with a task ID multiple times in order to retrieve logs from multiple specific tasks. A specific window of logs can be requested by passing --start and --end options with a time expression. The time expression can be either a duration or a timestamp: - Duration (e.g. -1h [one hour ago], -1h10m30s [one hour, ten minutes, and thirty seconds ago], 2h [two hours from now]) - Timestamp with optional timezone in the format of YYYY-MM-DD HH:MM:SS [TZ]; timezone will default to UTC if omitted (e.g. 2017-12-22 15:10:03 EST) You can filter logs for specific term by passing a filter expression via the --filter flag. Pass a single term to search for that term, pass multiple terms to search for log messages that include all terms.`, Args: cobra.ExactArgs(1), PreRun: func(cmd *cobra.Command, args []string) { }, Run: func(cmd *cobra.Command, args []string) { operation := &GetLogsOperation{ LogGroupName: fmt.Sprintf(serviceLogGroupFormat, args[0]), Filter: flagServiceLogsFilter, Follow: flagServiceLogsFollow, Namespace: args[0], } operation.AddTasks(flagServiceLogsTasks) operation.AddStartTime(flagServiceLogsStartTime) operation.AddEndTime(flagServiceLogsEndTime) GetLogs(operation) }, } func init() { serviceCmd.AddCommand(serviceLogsCmd) serviceLogsCmd.Flags().BoolVarP(&flagServiceLogsFollow, "follow", "f", false, "Poll logs and continuously print new events") serviceLogsCmd.Flags().StringVar(&flagServiceLogsFilter, "filter", "", "Filter pattern to apply") serviceLogsCmd.Flags().StringVar(&flagServiceLogsStartTime, "start", "", "Earliest time to return logs (e.g. -1h, 2018-01-01 09:36:00 EST") serviceLogsCmd.Flags().StringVar(&flagServiceLogsEndTime, "end", "", "Latest time to return logs (e.g. 3y, 2021-01-20 12:00:00 EST") serviceLogsCmd.Flags().StringSliceVarP(&flagServiceLogsTasks, "task", "t", []string{}, "Show logs from specific task (can be specified multiple times)") } ================================================ FILE: cmd/service_ps.go ================================================ package cmd import ( "fmt" "os" "text/tabwriter" "github.com/awslabs/fargatecli/console" EC2 "github.com/awslabs/fargatecli/ec2" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceProcessListOperation struct { ServiceName string } var servicePsCmd = &cobra.Command{ Use: "ps ", Short: "List running tasks for a service", Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceProcessListOperation{ ServiceName: args[0], } getServiceProcessList(operation) }, } func init() { serviceCmd.AddCommand(servicePsCmd) } func getServiceProcessList(operation *ServiceProcessListOperation) { var eniIds []string ecs := ECS.New(sess, clusterName) ec2 := EC2.New(sess) tasks := ecs.DescribeTasksForService(operation.ServiceName) for _, task := range tasks { if task.EniId != "" { eniIds = append(eniIds, task.EniId) } } if len(tasks) > 0 { enis := ec2.DescribeNetworkInterfaces(eniIds) w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "ID\tIMAGE\tSTATUS\tRUNNING\tIP\tCPU\tMEMORY\t") for _, t := range tasks { fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", t.TaskId, t.Image, Humanize(t.LastStatus), t.RunningFor(), enis[t.EniId].PublicIpAddress, t.Cpu, t.Memory, ) } w.Flush() } else { console.Info("No tasks found") } } ================================================ FILE: cmd/service_restart.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceRestartOperation struct { ServiceName string } var serviceRestartCmd = &cobra.Command{ Use: "restart ", Short: "Restart service", Long: `Restart service Creates a new set of tasks for the service and stops the previous tasks. This is useful if your service needs to reload data cached from an external source, for example.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceRestartOperation{ ServiceName: args[0], } restartService(operation) }, } func init() { serviceCmd.AddCommand(serviceRestartCmd) } func restartService(operation *ServiceRestartOperation) { ecs := ECS.New(sess, clusterName) ecs.RestartService(operation.ServiceName) console.Info("Restarted %s", operation.ServiceName) } ================================================ FILE: cmd/service_scale.go ================================================ package cmd import ( "fmt" "regexp" "strconv" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) const validScalePattern = "[-\\+]?[0-9]+" type ScaleServiceOperation struct { ServiceName string DesiredCount int64 } func (o *ScaleServiceOperation) SetScale(scaleExpression string) { ecs := ECS.New(sess, clusterName) validScale := regexp.MustCompile(validScalePattern) if !validScale.MatchString(scaleExpression) { console.ErrorExit(fmt.Errorf("Invalid scale expression %s", scaleExpression), "Invalid command line argument") } if scaleExpression[0] == '+' || scaleExpression[0] == '-' { if s, err := strconv.ParseInt(scaleExpression[1:len(scaleExpression)], 10, 64); err == nil { currentDesiredCount := ecs.GetDesiredCount(o.ServiceName) if scaleExpression[0] == '+' { o.DesiredCount = currentDesiredCount + s } else if scaleExpression[0] == '-' { o.DesiredCount = currentDesiredCount - s } } } else if s, err := strconv.ParseInt(scaleExpression, 10, 64); err == nil { o.DesiredCount = s } else { console.ErrorExit(fmt.Errorf("Invalid scale expression %s", scaleExpression), "Invalid command line argument") } if o.DesiredCount < 0 { console.ErrorExit(fmt.Errorf("requested scale %d < 0", o.DesiredCount), "Invalid command line argument") } } var serviceScaleCmd = &cobra.Command{ Use: "scale ", Short: "Changes the number of tasks running for the service", Long: `Scale number of tasks in a service Changes the number of desired tasks to be run in a service by the given scale expression. A scale expression can either be an absolute number or a delta specified with a sign such as +5 or -2.`, Args: cobra.ExactArgs(2), Run: func(cmd *cobra.Command, args []string) { operation := &ScaleServiceOperation{ ServiceName: args[0], } operation.SetScale(args[1]) scaleService(operation) }, } func init() { serviceCmd.AddCommand(serviceScaleCmd) } func scaleService(operation *ScaleServiceOperation) { ecs := ECS.New(sess, clusterName) ecs.SetDesiredCount(operation.ServiceName, operation.DesiredCount) console.Info("Scaled service %s to %d", operation.ServiceName, operation.DesiredCount) } ================================================ FILE: cmd/service_update.go ================================================ package cmd import ( "fmt" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type ServiceUpdateOperation struct { ServiceName string Cpu string Memory string Service ECS.Service } func (o *ServiceUpdateOperation) Validate() { ecs := ECS.New(sess, clusterName) if o.Cpu == "" && o.Memory == "" { console.ErrorExit(fmt.Errorf("--cpu and/or --memory must be supplied"), "Invalid command line arguments") } o.Service = ecs.DescribeService(o.ServiceName) cpu, memory := ecs.GetCpuAndMemoryFromTaskDefinition(o.Service.TaskDefinitionArn) if o.Cpu == "" { o.Cpu = cpu } if o.Memory == "" { o.Memory = memory } err := validateCpuAndMemory(o.Cpu, o.Memory) if err != nil { console.ErrorExit(err, "Invalid settings: %s CPU units / %s MiB", o.Cpu, o.Memory) } } var ( flagServiceUpdateCpu string flagServiceUpdateMemory string ) var serviceUpdateCmd = &cobra.Command{ Use: "update --cpu | --memory ", Short: "Update service configuration", Long: `Update service configuration CPU and memory settings are specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | At least one of --cpu or --memory must be specified.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &ServiceUpdateOperation{ ServiceName: args[0], Cpu: flagServiceUpdateCpu, Memory: flagServiceUpdateMemory, } operation.Validate() updateService(operation) }, } func init() { serviceCmd.AddCommand(serviceUpdateCmd) serviceUpdateCmd.Flags().StringVarP(&flagServiceUpdateCpu, "cpu", "c", "", "Amount of cpu units to allocate for each task") serviceUpdateCmd.Flags().StringVarP(&flagServiceUpdateMemory, "memory", "m", "", "Amount of MiB to allocate for each task") } func updateService(operation *ServiceUpdateOperation) { ecs := ECS.New(sess, clusterName) newTaskDefinitionArn := ecs.UpdateTaskDefinitionCpuAndMemory( operation.Service.TaskDefinitionArn, operation.Cpu, operation.Memory, ) ecs.UpdateServiceTaskDefinition(operation.ServiceName, newTaskDefinitionArn) console.Info("Updated service %s to %s CPU units / %s MiB", operation.ServiceName, operation.Cpu, operation.Memory) } ================================================ FILE: cmd/string_util.go ================================================ package cmd import "strings" // Humanize takes strings intended for machines and prettifies them for humans. func Humanize(s string) string { s = strings.Replace(s, "_", " ", -1) s = strings.ToLower(s) return s } // Titleize humanizes a string and returns it in Title Case. func Titleize(s string) string { s = Humanize(s) s = strings.Title(s) return s } // Map applies a func to all members of a slice of strings and returns a new slice of the results. func Map(vs []string, f func(string) string) []string { vsm := make([]string, len(vs)) for i, v := range vs { vsm[i] = f(v) } return vsm } ================================================ FILE: cmd/string_util_test.go ================================================ package cmd import "fmt" func ExampleHumanize() { fmt.Println(Humanize("HELLO_COMPUTER")) // Output: hello computer } func ExampleTitleize() { fmt.Println(Titleize("HELLO_COMPUTER")) // Output: Hello Computer } func ExampleMap() { reverse := func(s string) string { r := []rune(s) for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 { r[i], r[j] = r[j], r[i] } return string(r) } fmt.Printf("%v", Map([]string{"Pippin", "Merry"}, reverse)) // Output: [nippiP yrreM] } ================================================ FILE: cmd/task.go ================================================ package cmd import ( "github.com/spf13/cobra" ) const taskLogGroupFormat = "/fargate/task/%s" var taskCmd = &cobra.Command{ Use: "task", Short: "Manage tasks", Long: `Manage tasks Tasks are one-time executions of your container. Instances of your task are run until you manually stop them either through AWS APIs, the AWS Management Console, or fargate task stop, or until they are interrupted for any reason.`, } func init() { rootCmd.AddCommand(taskCmd) } ================================================ FILE: cmd/task_info.go ================================================ package cmd import ( "fmt" "strings" "github.com/awslabs/fargatecli/console" EC2 "github.com/awslabs/fargatecli/ec2" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type TaskInfoOperation struct { TaskGroupName string TaskIds []string } var flagTaskInfoTasks []string var taskInfoCmd = &cobra.Command{ Use: "info ", Short: "Inspect tasks", Long: `Inspect tasks Shows extended information for each running task within a task group or for specific tasks specified with the --task flag. Information includes environment variables which could differ between tasks in a task group. To inspect multiple specific tasks within a task group specific --task with a task ID multiple times.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &TaskInfoOperation{ TaskGroupName: args[0], TaskIds: flagTaskInfoTasks, } getTaskInfo(operation) }, } func init() { taskCmd.AddCommand(taskInfoCmd) taskInfoCmd.Flags().StringSliceVarP(&flagTaskInfoTasks, "task", "t", []string{}, "Get info for specific task instances (can be specified multiple times)") } func getTaskInfo(operation *TaskInfoOperation) { var tasks []ECS.Task var eniIds []string ecs := ECS.New(sess, clusterName) ec2 := EC2.New(sess) if len(operation.TaskIds) > 0 { tasks = ecs.DescribeTasks(operation.TaskIds) } else { tasks = ecs.DescribeTasksForTaskGroup(operation.TaskGroupName) } if len(tasks) == 0 { console.InfoExit("No tasks found") } for _, task := range tasks { if task.EniId != "" { eniIds = append(eniIds, task.EniId) } } enis := ec2.DescribeNetworkInterfaces(eniIds) console.KeyValue("Task Group Name", "%s\n", operation.TaskGroupName) console.KeyValue("Task Instances", "%d\n", len(tasks)) for _, task := range tasks { eni := enis[task.EniId] console.KeyValue(" "+task.TaskId, "\n") console.KeyValue(" Image", "%s\n", task.Image) console.KeyValue(" Status", "%s\n", Humanize(task.LastStatus)) console.KeyValue(" Started At", "%s\n", task.CreatedAt) console.KeyValue(" IP", "%s\n", eni.PublicIpAddress) console.KeyValue(" CPU", "%s\n", task.Cpu) console.KeyValue(" Memory", "%s\n", task.Memory) if task.TaskRole != "" { console.KeyValue(" Task Role", "%s\n", task.TaskRole) } console.KeyValue(" Subnet", "%s\n", task.SubnetId) console.KeyValue(" Security Groups", "%s\n", strings.Join(eni.SecurityGroupIds, ", ")) if len(task.EnvVars) > 0 { console.KeyValue(" Environment Variables", "\n") for _, envVar := range task.EnvVars { fmt.Printf(" %s=%s\n", envVar.Key, envVar.Value) } } } } ================================================ FILE: cmd/task_list.go ================================================ package cmd import ( "fmt" "os" "text/tabwriter" "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) var taskListCmd = &cobra.Command{ Use: "list", Short: "List running task groups", Run: func(cmd *cobra.Command, args []string) { listTaskGroups() }, } func init() { taskCmd.AddCommand(taskListCmd) } func listTaskGroups() { ecs := ECS.New(sess, clusterName) taskGroups := ecs.ListTaskGroups() if len(taskGroups) == 0 { console.InfoExit("No tasks running") } w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "NAME\tINSTANCES") for _, taskGroup := range taskGroups { fmt.Fprintf(w, "%s\t%d\n", taskGroup.TaskGroupName, taskGroup.Instances, ) } w.Flush() } ================================================ FILE: cmd/task_logs.go ================================================ package cmd import ( "fmt" "github.com/spf13/cobra" ) var ( flagTaskLogsFilter string flagTaskLogsEndTime string flagTaskLogsStartTime string flagTaskLogsFollow bool flagTaskLogsTasks []string ) var taskLogsCmd = &cobra.Command{ Use: "logs ", Short: "Show logs from tasks", Long: `Show logs from tasks Return either a specific segment of task logs or tail logs in real-time using the --follow option. Logs are prefixed by their log stream name which is in the format of "fargate//." Follow will continue to run and return logs until interrupted by Control-C. If --follow is passed --end cannot be specified. Logs can be returned for specific tasks within a task group by passing a task ID via the --task flag. Pass --task with a task ID multiple times in order to retrieve logs from multiple specific tasks. A specific window of logs can be requested by passing --start and --end options with a time expression. The time expression can be either a duration or a timestamp: - Duration (e.g. -1h [one hour ago], -1h10m30s [one hour, ten minutes, and thirty seconds ago], 2h [two hours from now]) - Timestamp with optional timezone in the format of YYYY-MM-DD HH:MM:SS [TZ]; timezone will default to UTC if omitted (e.g. 2017-12-22 15:10:03 EST) You can filter logs for specific term by passing a filter expression via the --filter flag. Pass a single term to search for that term, pass multiple terms to search for log messages that include all terms.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &GetLogsOperation{ LogGroupName: fmt.Sprintf(taskLogGroupFormat, args[0]), Filter: flagTaskLogsFilter, Follow: flagTaskLogsFollow, Namespace: args[0], } operation.AddTasks(flagTaskLogsTasks) operation.AddStartTime(flagTaskLogsStartTime) operation.AddEndTime(flagTaskLogsEndTime) GetLogs(operation) }, } func init() { taskCmd.AddCommand(taskLogsCmd) taskLogsCmd.Flags().BoolVarP(&flagTaskLogsFollow, "follow", "f", false, "Poll logs and continuously print new events") taskLogsCmd.Flags().StringVar(&flagTaskLogsFilter, "filter", "", "Filter pattern to apply") taskLogsCmd.Flags().StringVar(&flagTaskLogsStartTime, "start", "", "Earliest time to return logs (e.g. -1h, 2018-01-01 09:36:00 EST") taskLogsCmd.Flags().StringVar(&flagTaskLogsEndTime, "end", "", "Latest time to return logs (e.g. 3y, 2021-01-20 12:00:00 EST") taskLogsCmd.Flags().StringSliceVarP(&flagTaskLogsTasks, "task", "t", []string{}, "Show logs from specific task (can be specified multiple times)") } ================================================ FILE: cmd/task_ps.go ================================================ package cmd import ( "fmt" "os" "text/tabwriter" "github.com/awslabs/fargatecli/console" EC2 "github.com/awslabs/fargatecli/ec2" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type TaskProcessListOperation struct { TaskName string } var taskPsCmd = &cobra.Command{ Use: "ps ", Short: "List running tasks", Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &TaskProcessListOperation{ TaskName: args[0], } getTaskProcessList(operation) }, } func init() { taskCmd.AddCommand(taskPsCmd) } func getTaskProcessList(operation *TaskProcessListOperation) { var eniIds []string ecs := ECS.New(sess, clusterName) ec2 := EC2.New(sess) tasks := ecs.DescribeTasksForTaskGroup(operation.TaskName) for _, task := range tasks { if task.EniId != "" { eniIds = append(eniIds, task.EniId) } } if len(tasks) == 0 { console.InfoExit("No tasks found") } enis := ec2.DescribeNetworkInterfaces(eniIds) w := new(tabwriter.Writer) w.Init(os.Stdout, 0, 8, 1, '\t', 0) fmt.Fprintln(w, "ID\tIMAGE\tSTATUS\tRUNNING\tIP\tCPU\tMEMORY\t") for _, t := range tasks { fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\t%s\n", t.TaskId, t.Image, Humanize(t.LastStatus), t.RunningFor(), enis[t.EniId].PublicIpAddress, t.Cpu, t.Memory, ) } w.Flush() } ================================================ FILE: cmd/task_run.go ================================================ package cmd import ( CWL "github.com/awslabs/fargatecli/cloudwatchlogs" "github.com/awslabs/fargatecli/console" "github.com/awslabs/fargatecli/docker" EC2 "github.com/awslabs/fargatecli/ec2" ECR "github.com/awslabs/fargatecli/ecr" ECS "github.com/awslabs/fargatecli/ecs" "github.com/awslabs/fargatecli/git" IAM "github.com/awslabs/fargatecli/iam" "github.com/spf13/cobra" ) const typeTask string = "task" type TaskRunOperation struct { Cpu string EnvVars []ECS.EnvVar Image string Memory string Num int64 SecurityGroupIds []string SubnetIds []string TaskName string TaskRole string TaskCommand []string } func (o *TaskRunOperation) Validate() { err := validateCpuAndMemory(o.Cpu, o.Memory) if err != nil { console.ErrorExit(err, "Invalid settings: %s CPU units / %s MiB", o.Cpu, o.Memory) } if o.Num < 1 { console.ErrorExit(err, "Invalid number of tasks: %d, num must be > 1", o.Num) } } func (o *TaskRunOperation) SetEnvVars(inputEnvVars []string) { o.EnvVars = extractEnvVars(inputEnvVars) } var ( flagTaskRunNum int64 flagTaskRunCpu string flagTaskRunEnvVars []string flagTaskRunImage string flagTaskRunMemory string flagTaskRunSecurityGroupIds []string flagTaskRunSubnetIds []string flagTaskRunTaskRole string flagTaskRunTaskCommand []string ) var taskRunCmd = &cobra.Command{ Use: "run ", Short: "Run new tasks", Long: `Run new tasks You must specify a task group name in order to interact with the task(s) in subsequent commands to view logs, stop and inspect tasks. Task group names do not have to be unique -- multiple configurations of task instances can be started with the same task group. Multiple instances of a task can be run by specifying a number in the --num flag. If no number is specified, a single task instance will be run. CPU and memory settings can be optionally specified as CPU units and mebibytes respectively using the --cpu and --memory flags. Every 1024 CPU units is equivilent to a single vCPU. AWS Fargate only supports certain combinations of CPU and memory configurations: | CPU (CPU Units) | Memory (MiB) | | --------------- | ------------------------------------- | | 256 | 512, 1024, or 2048 | | 512 | 1024 through 4096 in 1GiB increments | | 1024 | 2048 through 8192 in 1GiB increments | | 2048 | 4096 through 16384 in 1GiB increments | | 4096 | 8192 through 30720 in 1GiB increments | If not specified, fargate will launch minimally sized tasks at 0.25 vCPU (256 CPU units) and 0.5GB (512 MiB) of memory. The Docker container image to use in the task can be optionally specified via the --image flag. If not specified, fargate will build a new Docker container image from the current working directory and push it to Amazon ECR in a repository named for the task group. If the current working directory is a git repository, the container image will be tagged with the short ref of the HEAD commit. If not, a timestamp in the format of YYYYMMDDHHMMSS will be used. Environment variables can be specified via the --env flag. Specify --env with a key=value parameter multiple times to add multiple variables. Security groups can optionally be specified for the task by passing the --security-group-id flag with a security group ID. To add multiple security groups, pass --security-group-id with a security group ID multiple times. If --security-group-id is omitted, a permissive security group will be applied to the task. By default, the task will be created in the default VPC and attached to the default VPC subnets for each availability zone. You can override this by specifying explicit subnets by passing the --subnet-id flag with a subnet ID. A task role can be optionally specified via the --task-role flag by providing eith a full IAM role ARN or the name of an IAM role. The tasks will be able to assume this role. The default command of the docker image can be overridden using the --task-command flag, where the value is a string of comma seperated values representing the command. These values will be placed into an array as per the requirements of the docker CMD syntax`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &TaskRunOperation{ Cpu: flagTaskRunCpu, Image: flagTaskRunImage, Memory: flagTaskRunMemory, Num: flagTaskRunNum, SecurityGroupIds: flagTaskRunSecurityGroupIds, SubnetIds: flagTaskRunSubnetIds, TaskName: args[0], TaskRole: flagTaskRunTaskRole, TaskCommand: flagTaskRunTaskCommand, } operation.SetEnvVars(flagTaskRunEnvVars) operation.Validate() runTask(operation) }, } func init() { taskRunCmd.Flags().Int64VarP(&flagTaskRunNum, "num", "n", 1, "Number of task instances to run") taskRunCmd.Flags().StringSliceVarP(&flagTaskRunEnvVars, "env", "e", []string{}, "Environment variables to set [e.g. KEY=value] (can be specified multiple times)") taskRunCmd.Flags().StringVarP(&flagTaskRunCpu, "cpu", "c", "256", "Amount of cpu units to allocate for each task") taskRunCmd.Flags().StringVarP(&flagTaskRunImage, "image", "i", "", "Docker image to run; if omitted Fargate will build an image from the Dockerfile in the current directory") taskRunCmd.Flags().StringVarP(&flagTaskRunMemory, "memory", "m", "512", "Amount of MiB to allocate for each task") taskRunCmd.Flags().StringSliceVar(&flagTaskRunSecurityGroupIds, "security-group-id", []string{}, "ID of a security group to apply to the task (can be specified multiple times)") taskRunCmd.Flags().StringSliceVar(&flagTaskRunSubnetIds, "subnet-id", []string{}, "ID of a subnet in which to place the task (can be specified multiple times)") taskRunCmd.Flags().StringVarP(&flagTaskRunTaskRole, "task-role", "", "", "Name or ARN of an IAM role that the tasks can assume") taskRunCmd.Flags().StringSliceVar(&flagTaskRunTaskCommand, "task-command", []string{}, "Command to run inside container instead of the one specified in the docker image") taskCmd.AddCommand(taskRunCmd) } func runTask(operation *TaskRunOperation) { cwl := CWL.New(sess) ec2 := EC2.New(sess) ecr := ECR.New(sess) ecs := ECS.New(sess, clusterName) iam := IAM.New(sess) ecsTaskExecutionRoleArn := iam.CreateEcsTaskExecutionRole() logGroupName := cwl.CreateLogGroup(taskLogGroupFormat, operation.TaskName) if len(operation.SecurityGroupIds) == 0 { defaultSecurityGroupID, _ := ec2.GetDefaultSecurityGroupID() operation.SecurityGroupIds = []string{defaultSecurityGroupID} } if len(operation.SubnetIds) == 0 { operation.SubnetIds, _ = ec2.GetDefaultSubnetIDs() } if operation.Image == "" { var repositoryUri, tag string if ecr.IsRepositoryCreated(operation.TaskName) { repositoryUri = ecr.GetRepositoryUri(operation.TaskName) } else { repositoryUri = ecr.CreateRepository(operation.TaskName) } if git.IsCwdGitRepo() { tag = git.GetShortSha() } else { tag = docker.GenerateTag() } repository := docker.NewRepository(repositoryUri) username, password := ecr.GetUsernameAndPassword() repository.Login(username, password) repository.Build(tag) repository.Push(tag) operation.Image = repository.UriFor(tag) } taskDefinitionArn := ecs.CreateTaskDefinition( &ECS.CreateTaskDefinitionInput{ Cpu: operation.Cpu, EnvVars: operation.EnvVars, ExecutionRoleArn: ecsTaskExecutionRoleArn, Image: operation.Image, LogGroupName: logGroupName, LogRegion: region, Memory: operation.Memory, Name: operation.TaskName, Type: typeTask, TaskRole: operation.TaskRole, TaskCommand: operation.TaskCommand, }, ) ecs.RunTask( &ECS.RunTaskInput{ ClusterName: clusterName, Count: operation.Num, TaskName: operation.TaskName, TaskDefinitionArn: taskDefinitionArn, SubnetIds: operation.SubnetIds, SecurityGroupIds: operation.SecurityGroupIds, }, ) console.Info("Running task %s", operation.TaskName) } ================================================ FILE: cmd/task_stop.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/console" ECS "github.com/awslabs/fargatecli/ecs" "github.com/spf13/cobra" ) type TaskStopOperation struct { TaskGroupName string TaskIds []string } var ( flagTaskStopTasks []string ) var taskStopCmd = &cobra.Command{ Use: "stop ", Short: "Stop tasks", Long: `Stop tasks Stops all tasks within a task group if run with only a task group name or stops individual tasks if one or more tasks are passed via the --task flag. Specify --task with a task ID parameter multiple times to stop multiple specific tasks.`, Args: cobra.ExactArgs(1), Run: func(cmd *cobra.Command, args []string) { operation := &TaskStopOperation{ TaskGroupName: args[0], TaskIds: flagTaskStopTasks, } stopTasks(operation) }, } func init() { taskCmd.AddCommand(taskStopCmd) taskStopCmd.Flags().StringSliceVarP(&flagTaskStopTasks, "task", "t", []string{}, "Stop specific task instances (can be specified multiple times)") } func stopTasks(operation *TaskStopOperation) { var taskCount int ecs := ECS.New(sess, clusterName) if len(operation.TaskIds) > 0 { taskCount = len(operation.TaskIds) ecs.StopTasks(operation.TaskIds) } else { var taskIds []string tasks := ecs.DescribeTasksForTaskGroup(operation.TaskGroupName) for _, task := range tasks { taskIds = append(taskIds, task.TaskId) } taskCount = len(taskIds) ecs.StopTasks(taskIds) } if taskCount == 1 { console.Info("Stopped %d task", taskCount) } else { console.Info("Stopped %d tasks", taskCount) } } ================================================ FILE: cmd/testdata/certificate.crt ================================================ -----BEGIN CERTIFICATE----- MIID+TCCAuGgAwIBAgIJAJ2PPB292VTPMA0GCSqGSIb3DQEBBQUAMIGSMQswCQYD VQQGEwJVUzERMA8GA1UECAwITmV3IFlvcmsxETAPBgNVBAcMCE5ldyBZb3JrMSEw HwYDVQQKDBhJbnRlcm5ldCBXaWRnaXRzIFB0eSBMdGQxGTAXBgNVBAMMEHRlc3Qu cGlnbmF0YS5jb20xHzAdBgkqhkiG9w0BCQEWEGpvaG5AcGlnbmF0YS5jb20wHhcN MTgwMjAzMTM0NzM3WhcNMjgwMjAxMTM0NzM3WjCBkjELMAkGA1UEBhMCVVMxETAP BgNVBAgMCE5ldyBZb3JrMREwDwYDVQQHDAhOZXcgWW9yazEhMB8GA1UECgwYSW50 ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMRkwFwYDVQQDDBB0ZXN0LnBpZ25hdGEuY29t MR8wHQYJKoZIhvcNAQkBFhBqb2huQHBpZ25hdGEuY29tMIIBIjANBgkqhkiG9w0B AQEFAAOCAQ8AMIIBCgKCAQEAoNOwzw7dzqat3GLi9Zs+AaWVLl8TBrS5cIwcDKnQ 6B6gDiWemnVAG5gsXbTSHbCtUvjdsaaheuV0H+yPFRzuSQJ+gOufUTvRJm9n80xQ mSPp/dECsMpJjndT7FMtt0soP7hbiAGT0huZq8vNnOHFIjWfdjfYnGnV9AUKX4g2 J2P7cJQgj9aa+hYu2t0RwGuMZibpjkLfplsPtt+dNa9e5C1mPR6gMNlIeEiRtsfc 4DdKgaQb+OeoQYJcc51MQC4ZezNhjHQxPcPp7F1o8dEWGyyqIc+BytGg/w8tj6Xo M4kyzHsCtwJpRp12zgTacQwxHlChroHZ8h5ueGx9Jp9U2QIDAQABo1AwTjAdBgNV HQ4EFgQUC1qoXFJ1bL1esoNI/0SrTPLA3okwHwYDVR0jBBgwFoAUC1qoXFJ1bL1e soNI/0SrTPLA3okwDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAblky sS1m2mAKbR+lPjOXf2Q5GcEXyqlYrzlta1ds6LzoZjpm0ezNdXXD/f1oBA6OFaDf SpDgtxQaZqVqPoCNAvEUJGGojN6KQkDWKieEv3d+FnHZuSrwmzD+YGO0kWDHDnkg NDhll3RB6/Fij7aOfXLsuHZrGHkzwktWQBMEvnpLs1fHmLJgKTlLXroR3q7QL+jm Zzv1znn1DqMkrasp+GDixbnLoYeZFcIexeuxWDsjdbEVQThvdC8A4elrVhKWgggV 2o3ak6iJr5TOOs/7i5TnzHq5YT1gzDX/pETIZXEl/BKafIjqU0zYUism6gWQJ1lo AKUr4Eclnh1T9rqS5g== -----END CERTIFICATE----- ================================================ FILE: cmd/testdata/chain.crt ================================================ -----BEGIN CERTIFICATE----- MIIEoDCCA4igAwIBAgIQBpaPlkroI1bHThfCtTZbADANBgkqhkiG9w0BAQsFADBs MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j ZSBFViBSb290IENBMB4XDTE3MTEwNjEyMjI1N1oXDTI3MTEwNjEyMjI1N1owXzEL MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 LmRpZ2ljZXJ0LmNvbTEeMBwGA1UEAxMVVGhhd3RlIEVWIFJTQSBDQSAyMDE4MIIB IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp0Cu52zmdJFnSezXMKvL0rso WgA/1X7OxjMQHsAllID1eDG836ptJXSTPg+DoEenHfkKyw++wXobgahr0cU/2v8R WR3fID53ZDhEGHzS+Ol7V+HRtZG5teMWCY7gldtBQH0r7xUEp/3ISVsZUVBqtUmL VJlf9nxJD6Cxp4LBlcJJ8+N6kSkV+fA+WdQc0HYhXSg3PxJP7XSU28Wc7gf6y9kZ zQhK4WrZLRrHHbHC2QXdqQYUxR927QV+UCNXnlbTcZy2QpxWTPLzK+/cKXX4cwP6 MGF7+8RnUgHlij/5V2k/tIF9ep4B72ucqaS/UhEPpIN/T7A3OAw995yrB38glQID AQABo4IBSTCCAUUwHQYDVR0OBBYEFOcB/AwWGMp9sozshyejb2GBO4Q5MB8GA1Ud IwQYMBaAFLE+w2kD+L9HAdSYJhoIAu9jZCvDMA4GA1UdDwEB/wQEAwIBhjAdBgNV HSUEFjAUBggrBgEFBQcDAQYIKwYBBQUHAwIwEgYDVR0TAQH/BAgwBgEB/wIBADA0 BggrBgEFBQcBAQQoMCYwJAYIKwYBBQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0 LmNvbTBLBgNVHR8ERDBCMECgPqA8hjpodHRwOi8vY3JsMy5kaWdpY2VydC5jb20v RGlnaUNlcnRIaWdoQXNzdXJhbmNlRVZSb290Q0EuY3JsMD0GA1UdIAQ2MDQwMgYE VR0gADAqMCgGCCsGAQUFBwIBFhxodHRwczovL3d3dy5kaWdpY2VydC5jb20vQ1BT MA0GCSqGSIb3DQEBCwUAA4IBAQAWGka+5ffLpfFuzT+WlwDRwhyTZSunnvecZWZT PPKXipynjpXx5dK8YG+2XoH74285GR1UABuvHMFV94XeDET9Pzz5s/NHS1/eAr5e GdwfBl80XwPkwXaYqzRtw6J4RAxeLqcbibhUQv9Iev9QcP0kNPyJu413Xov76mSu JlGThKzcurJPive2eLmwmoIgTPH11N/IIO9nHLVe8KTkt+FGgZCOWHA3kbFBZR39 Mn2hFS974rhUkM+VS9KbCiQQ5OwkfbZ/6BINkE1CMtiESZ2WkbxJKPsF3dN7p9DF YWiQSbYjFP+rCT0/MkaHHYUkEvLNPgyJ6z29eMf0DjLu/SXJ -----END CERTIFICATE----- ================================================ FILE: cmd/testdata/private.key ================================================ -----BEGIN RSA PRIVATE KEY----- MIIEpAIBAAKCAQEAoNOwzw7dzqat3GLi9Zs+AaWVLl8TBrS5cIwcDKnQ6B6gDiWe mnVAG5gsXbTSHbCtUvjdsaaheuV0H+yPFRzuSQJ+gOufUTvRJm9n80xQmSPp/dEC sMpJjndT7FMtt0soP7hbiAGT0huZq8vNnOHFIjWfdjfYnGnV9AUKX4g2J2P7cJQg j9aa+hYu2t0RwGuMZibpjkLfplsPtt+dNa9e5C1mPR6gMNlIeEiRtsfc4DdKgaQb +OeoQYJcc51MQC4ZezNhjHQxPcPp7F1o8dEWGyyqIc+BytGg/w8tj6XoM4kyzHsC twJpRp12zgTacQwxHlChroHZ8h5ueGx9Jp9U2QIDAQABAoIBACR1eQqnmx8C6D0i 6cK2C8uBxxz5Dq4hgDyEdsNkJ+jHMI+kdZ0cYYkf6Ubg/BUg/Vnm8xMX7FmY9Mdb 8F/f7CD/AMCnKbnXrqVg8hbUwRzGaIBSxqJfaWdzo8HaZW29CwXO/GkLuoASI7cv f5BGGlOUBm9dX6ytzYQBNIXNskEhbFjbsiqSx3YlHoTP1qukHMz8rwBXc4wWRj2Q 4M4dqIGVW8OvsBcf4EzUokz8W+FMm14PBF7LkdxP+pAiQi4qqJeJiAmtnc20z7uD 6YNDcg6a0HosZyq5/AulAxt62JiiPrpP3njGEaEjsEU23qMbWd220CH9d7YXVCZM r5Cc4MUCgYEAzS4CX/HXu+Prw2wJbBRAfsXn0TiTzqi7E7uW6ZVWWAqW2ZSkIb0x /aXv+mLWA+ho3/D6/cysSY+pCGaewyPzsZRkOAhcpTww+1cXZFDpa0CKUTzBZ5tT XjpLO2VTvFJdAaXuad942qwiKr14w7CGaAhBCYUawpcjUM0hirBk0CsCgYEAyKle TOgkKJhV3VkKan5EyeOyfab0UcUPEQX3EoRoju+K6Z5FHcoaBpebYD9GAXdx1xdd jYW2k7diAZlKqAy5G+1SBW5ImFaDCZh3pIdRVtXLY9HCLUrac0NKioNEkyu3ZP0m dK4sfF6ZQTGPLP9hmdrlOeUJiEtnSZ1JbuGaqQsCgYEAmyaAazbAMHb/741BbrW9 s19JlV7X/fx/QkOmsUjYush/G1aX6l9bbvdMiSS1uszCiRx7XvGnEhUM96pJwTvt acnRIsHH9LaYP2ay7It2hkCOlzF++i5tEyK3gtlzQUNyyu1DZFG03H4vc+xEZo2U hRRAwcch3iVVciM7itkp0nMCgYEAoDfbu7x/Yop/xMUbs/wuIKVWF03/NmsJpKYG qRpgAgDyAacFuMtuDGVxAmCDHRiqJPvbDuz84uVBs9UZ7yR5iPrsyrlL7Zbl+ftr TEtfft4mEAWj7VYfJnlMQ1ycnIYDYPdghTms+4DtDUjs8RjYbWiCLr/Z5KGQTw7v W0F3pBECgYB4RIMXZVd97zfULizqRwDXRUiXh+6LGGnyx0DSVnt20dWr75e0uOcj /5xUWNm5CLQ9IVEmKMjzV4Zgs99T35NFOuA1zcUj0PNjxLehtnIKk2GMaFLVvcWs ylyxsI/61UUXa0qnzvSRNO2GLXkjvxZ6wsbgLCpQsArUWFgdc7URxA== -----END RSA PRIVATE KEY----- ================================================ FILE: cmd/vpc_operation.go ================================================ package cmd import ( "github.com/awslabs/fargatecli/ec2" ) type vpcOperation struct { ec2 ec2.Client output Output securityGroupIDs []string subnetIDs []string vpcID string } func (o *vpcOperation) setSubnetIDs(subnetIDs []string) error { o.output.Debug("Finding VPC ID [API=ec2 Action=DescribeSubnets]") vpcID, err := o.ec2.GetSubnetVPCID(subnetIDs[0]) if err != nil { return err } o.subnetIDs = subnetIDs o.vpcID = vpcID return nil } func (o *vpcOperation) setSecurityGroupIDs(securityGroupIDs []string) { o.securityGroupIDs = securityGroupIDs } func (o *vpcOperation) setDefaultSecurityGroupID() error { o.output.Debug("Finding default security group [API=ec2 Action=DescribeSecurityGroups]") defaultSecurityGroupID, err := o.ec2.GetDefaultSecurityGroupID() if err != nil { return err } if defaultSecurityGroupID == "" { o.output.Debug("Creating default security group [API=ec2 Action=CreateSecurityGroup]") defaultSecurityGroupID, err = o.ec2.CreateDefaultSecurityGroup() if err != nil { return err } o.output.Debug("Created default security group [ID=%s]", defaultSecurityGroupID) o.output.Debug("Configuring default security group [API=ec2 Action=AuthorizeSecurityGroupIngress]") if err := o.ec2.AuthorizeAllSecurityGroupIngress(defaultSecurityGroupID); err != nil { return err } } o.securityGroupIDs = []string{defaultSecurityGroupID} return nil } func (o *vpcOperation) setDefaultSubnetIDs() error { o.output.Debug("Finding default subnets [API=ec2 Action=DescribeSubnets]") subnetIDs, err := o.ec2.GetDefaultSubnetIDs() if err != nil { return err } o.output.Debug("Finding VPC ID [API=ec2 Action=DescribeSubnets]") vpcID, err := o.ec2.GetSubnetVPCID(subnetIDs[0]) if err != nil { return err } o.subnetIDs = subnetIDs o.vpcID = vpcID return nil } ================================================ FILE: cmd/vpc_operation_test.go ================================================ package cmd import ( "errors" "testing" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/cmd/mock" ec2client "github.com/awslabs/fargatecli/ec2/mock/client" ) func TestSetSubnetIDs(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setSubnetIDs([]string{"subnet-1234567"}) if err != nil { t.Errorf("expected no error, got: %v", err) } if len(operation.subnetIDs) != 1 { t.Fatalf("expected 1 subnet ID, got: %d", len(operation.subnetIDs)) } if expected := "subnet-1234567"; operation.subnetIDs[0] != expected { t.Errorf("expected: %s, got: %s", expected, operation.subnetIDs[0]) } if expected := "vpc-1234567"; operation.vpcID != expected { t.Errorf("expected: %s, got: %s", expected, operation.vpcID) } } func TestSetSubnetIDsError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("", errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setSubnetIDs([]string{"subnet-1234567"}) if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestSetDefaultSecurityGroupID(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("sg-1234567", nil) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSecurityGroupID() if err != nil { t.Errorf("expected no error, got: %v", err) } if len(operation.securityGroupIDs) != 1 { t.Fatalf("expected 1 security group ID, got: %d", len(operation.securityGroupIDs)) } if expected := "sg-1234567"; operation.securityGroupIDs[0] != expected { t.Errorf("expected: %s, got: %s", expected, operation.securityGroupIDs[0]) } } func TestSetDefaultSecurityGroupIDLookupError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSecurityGroupID() if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestSetDefaultSecurityGroupIDWithCreate(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil) mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("sg-1234567", nil) mockEC2Client.EXPECT().AuthorizeAllSecurityGroupIngress("sg-1234567").Return(nil) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSecurityGroupID() if err != nil { t.Errorf("expected no error, got: %v", err) } if len(operation.securityGroupIDs) != 1 { t.Fatalf("expected 1 security group ID, got: %d", len(operation.securityGroupIDs)) } if expected := "sg-1234567"; operation.securityGroupIDs[0] != expected { t.Errorf("expected: %s, got: %s", expected, operation.securityGroupIDs[0]) } } func TestSetDefaultSecurityGroupIDWithCreateError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil) mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("", errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSecurityGroupID() if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestSetDefaultSecurityGroupIDWithAuthorizeError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSecurityGroupID().Return("", nil) mockEC2Client.EXPECT().CreateDefaultSecurityGroup().Return("sg-1234567", nil) mockEC2Client.EXPECT().AuthorizeAllSecurityGroupIngress("sg-1234567").Return(errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSecurityGroupID() if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestSetDefaultSubnetIDs(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil) mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("vpc-1234567", nil) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSubnetIDs() if err != nil { t.Errorf("expected no error, got: %v", err) } if len(operation.subnetIDs) != 2 { t.Fatalf("expected 2 subnet IDs, got: %d", len(operation.subnetIDs)) } if expected := "subnet-1234567"; operation.subnetIDs[0] != expected { t.Errorf("expected: %s, got: %s", expected, operation.subnetIDs[0]) } if expected := "vpc-1234567"; operation.vpcID != expected { t.Errorf("expected: %s, got: %s", expected, operation.vpcID) } } func TestSetDefaultSubnetIDsLookupError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{}, errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSubnetIDs() if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } func TestSetDefaultSubnetIDsVPCError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := ec2client.NewMockClient(mockCtrl) mockOutput := &mock.Output{} mockEC2Client.EXPECT().GetDefaultSubnetIDs().Return([]string{"subnet-1234567", "subnet-abcdef"}, nil) mockEC2Client.EXPECT().GetSubnetVPCID("subnet-1234567").Return("", errors.New("boom")) operation := vpcOperation{ ec2: mockEC2Client, output: mockOutput, } err := operation.setDefaultSubnetIDs() if err == nil { t.Errorf("expected error, got none") } if expected := "boom"; err.Error() != expected { t.Errorf("expected: %s, got: %v", expected, err) } } ================================================ FILE: console/main.go ================================================ package console import ( "fmt" "os" "strconv" "github.com/mgutz/ansi" ) var ( Verbose = false Color = true ) var ( info = "[i] " debug = "[d] " issue = "[!] " shell = "[>] " colorInfo = white + "[" + blue + "i" + white + "]" + reset + " " colorDebug = white + "[" + orange + "d" + white + "]" + reset + " " colorIssue = white + "[" + red + "!" + white + "]" + reset + " " colorShell = white + "[" + green + ">" + white + "]" + reset + " " blue = ansi.ColorCode("blue+bh") white = ansi.ColorCode("white+bh") yellow = ansi.ColorCode("yellow+bh") green = ansi.ColorCode("green+bh") red = ansi.ColorCode("red+bh") reset = ansi.ColorCode("reset") orange = ansi.ColorCode("214+bh") ) func LogLine(prefix, msg string, color int) { if Color { colorCode := strconv.Itoa(color) fmt.Println(ansi.ColorCode(colorCode) + prefix + reset + " " + msg) } else { fmt.Println(prefix + " " + msg) } } func KeyValue(key, value string, a ...interface{}) { if Color { fmt.Fprintf(os.Stdout, white+key+reset+": "+value, a...) } else { fmt.Fprintf(os.Stdout, key+": "+value, a...) } } func Header(s string) { fmt.Print("\n") if Color { fmt.Print(white + s + reset + "\n") } else { fmt.Println(s) } } func Info(msg string, a ...interface{}) { if Color { fmt.Fprintf(os.Stdout, colorInfo+msg+reset+"\n", a...) } else { fmt.Fprintf(os.Stdout, info+msg+"\n", a...) } } func Debug(msg string, a ...interface{}) { if Verbose { if Color { fmt.Fprintf(os.Stdout, colorDebug+msg+reset+"\n", a...) } else { fmt.Fprintf(os.Stdout, debug+msg+"\n", a...) } } } func Shell(msg string, a ...interface{}) { if Color { fmt.Fprintf(os.Stdout, colorShell+green+msg+reset+"\n", a...) } else { fmt.Fprintf(os.Stdout, shell+msg+"\n", a...) } } func Issue(msg string, a ...interface{}) { if Color { fmt.Fprintf(os.Stderr, colorIssue+red+msg+reset+"\n", a...) } else { fmt.Fprintf(os.Stderr, issue+msg+"\n", a...) } } func Error(err error, msg string, a ...interface{}) { Issue(msg, a...) if err != nil { os.Stderr.WriteString(err.Error() + "\n") } } func InfoExit(msg string, a ...interface{}) { Info(msg, a...) os.Exit(0) } func ErrorExit(err error, msg string, a ...interface{}) { Error(err, msg, a...) os.Exit(1) } func IssueExit(msg string, a ...interface{}) { Issue(msg, a...) os.Exit(1) } func Exit(code int) { os.Exit(code) } func SetVerbose(verbose bool) { Verbose = verbose } ================================================ FILE: doc/website/index.html ================================================ fargate :: A CLI for AWS Fargate

fargate

Deploy serverless containers onto the cloud from your command line

fargate is a command-line interface to deploy containers to AWS Fargate. Using fargate, developers can easily run containers as one-off tasks or managed, highly available services secured by free TLS certificates. It bundles the power of AWS including Amazon Elastic Container Service (ECS), Amazon Elastic Container Registry (ECR), Elastic Load Balancing, AWS Certificate Manager, Amazon CloudWatch Logs, and Amazon Route 53 into an easy-to-use CLI.

Get Started jpignata/fargate

Run a Task from a Public Image

Tasks are one-time executions of your container. You can run a task with a public IP address from an image on Docker Hub in a single command:

$ fargate task run web --image nginx:latest
[i] Running task web

$ fargate task ps web
ID                                    IMAGE         STATUS   RUNNING  IP              CPU  MEMORY
8c35747a-7c1c-4efe-b55a-8dfbc1108d82  nginx:latest  Running  35s      34.228.17.157   256  512

$ curl -s http://34.228.17.157 | grep title
<title>Welcome to nginx!</title>

Run a Task from a Local Dockerfile

If you omit the image flag, fargate will build and push the application in the current working directory to Amazon ECR:

$ fargate task run web
[>] docker login --username AWS --password ******* 123456789012.dkr.ecr.us-east-1.amazonaws.com/web
[>] docker build --tag 123456789012.dkr.ecr.us-east-1.amazonaws.com/web:20171227050818 .
[>] docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/web:20171227050818 .
li] Running task web

Run a Service

Services are managed containers that are restarted if a failure occurs. Like a task, you can deploy a service using either a pre-existing Docker container or build and push it using fargate.

$ fargate service create myapp
[i] Created service myapp

Run a Load Balanced Service

Services can be placed behind either an HTTP/HTTPS or TCP load balancer to serve requests to multiple instances of your container from a single URL.

$ fargate lb create mylb --port 80
[i] Created load balancer mylb

$ fargate service create myapp --lb mylb --port 80
[i] Created service myapp

Deploy a New Image To a Service

Use fargate to either push images built separately via continuous integration by using the --image flag or build and push directly from your computer.

$ fargate service deploy myapp
...
[i] Deployed 123456789012.dkr.ecr.us-east-1.amazonaws.com/myapp:abcd1234 to service myapp

Scale Vertically

Containers running using AWS Fargate can range from a quarter of a vCPU to 4 vCPUs and from 0.5GB of RAM to 30GB. This command scales our containers to a single vCPU and 4GB of RAM:

$ fargate service update myapp --cpu 1024 --memory 4096
[i] Updated service myapp to 1024 CPU / 4096 MiB

Scale Horizontally

Services can scale to any number of instances with a single command.

$ fargate service scale web +2
[i] Scaled service web to 3

$ fargate service ps web
ID                                    IMAGE         STATUS   RUNNING  IP             CPU  MEMORY  DEPLOYMENT
8c35747a-7c1c-4efe-b55a-8dfbc1108d82  nginx:latest  Running  56s      34.228.17.157  256  512     1
0487456c-8dbe-49ff-b7e7-d772eee447af  nginx:latest  Running  56s      34.229.59.235  256  512     1
8c35747a-7c1c-4efe-b55a-8dfbc1108d82  nginx:latest  Running  2h57m1s  34.228.17.157  256  512     1

Secure a Load Balancer with a TLS Certificate

Load balancers can use HTTPS ports secured by a TLS certificate for your domain or domains. Domains hosted in Amazon Route 53 can be automatically validated from fargate.

$ fargate certificate request *.somanymachines.com
$ fargate certificate validate *.somanymachines.com
$ fargate lb create mylb --port 443 --certificate *.somanymachines.com
$ fargate service create myapp --lb mylb --port 80

Add Multiple Services to a Load Balancer

HTTP/HTTPS load balancers can support multiple services and will route to them based upon defined rules that match either the path or hostname of the request. This allows you to run a single service or a dozen microservices behind a single load balancer.

$ fargate lb create mylb --port 80
$ fargate service create myapp --lb mylb --port 80
$ fargate service create myservice --lb mylb --port 80 --rule PATH=/myservice/*
$ fargate service create myotherservice --lb mylb --port 80 --rule PATH=/myotherservice/*

View Logs from a Running Task or Service

fargate configures containers to log to Amazon CloudWatch Logs which allow you to view or follow a log in real-time. Tail logs using --follow or select a range of logs using start and end times expressed as durations (e.g. -1h, -1m30s or timestamps (e.g. 2017-12-12 15:00 EST)

$ fargate task logs myapp --follow --start "-15m" --filter "curl"
fargate/web/0487456c-8dbe-49ff-b7e7-d772eee447af 172.31.41.97 - - [27/Dec/2017:05:32:17 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.21.3 (i386-portbld-freebsd8.1) libcurl/7.21.3 OpenSSL/0.9.8n zlib/1.2.3" "199.233.217.27"
fargate/web/358c439f-0613-4d69-abe8-fe8b7a25f64e 172.31.4.10 - - [27/Dec/2017:05:32:19 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.21.3 (i386-portbld-freebsd8.1) libcurl/7.21.3 OpenSSL/0.9.8n zlib/1.2.3" "199.233.217.27"
fargate/web/8c35747a-7c1c-4efe-b55a-8dfbc1108d82 172.31.53.143 - - [27/Dec/2017:05:32:18 +0000] "GET / HTTP/1.1" 200 612 "-" "curl/7.21.3 (i386-portbld-freebsd8.1) libcurl/7.21.3 OpenSSL/0.9.8n zlib/1.2.3" "199.233.217.27"

Create an Alias Record to a Load Balancer

If you're hosting your domain using Amazon Route 53, you can create an alias record to your load balancer in a single command:

$ fargate lb alias mylb app.somanymachines.com
[i] Created alias record [app.somanymachines.com -> mylb-518172311.us-east-1.elb.amazonaws.com]

Get Started

macOS

64-bit

Linux

64-bit | 32-bit | Arm

Source

jpignata/fargate

================================================ FILE: doc/website/styles.css ================================================ body { font-family: 'Lato', sans-serif; margin-bottom: 700px; } pre { background-color: #111; color: #f5f5f5; padding: 1.2em; border-radius: 0.5em; } .examples .card:first-child { margin-top: 0; } .examples .card { margin-top: 2em; width: 100%; } .github { margin-top: 3em; } .github img { margin-right: 10px; } span.red { color: red; } span.blue { color: deepskyblue; } span.green { color: limegreen; } .btn { margin-right: 10px; } .btn img { margin-right: 10px; } .clear { clear: both; } img.icon { height: 25px; width: 25px; } .header { margin-top: 3em; margin-bottom: 3em; } @media (min-width: 992px) { .hed { float: left; } .hed-image { float: right; } .intro { clear: both; } } @media (max-width: 992px) { .hed { text-align: center; } .hed-image { text-align: center; } .intro { text-align: center; } .actions { text-align: center; } } @media (max-width: 575.99px) { .card { margin: 0 20px; } .header { margin-left: 0px; } } .video iframe { width: 100% margin: 0 auto; margin-bottom: 30px; } ================================================ FILE: docker/main.go ================================================ package docker import ( "os" "os/exec" "time" "github.com/awslabs/fargatecli/console" ) const timestampFormat = "20060102150405" func GenerateTag() string { return time.Now().UTC().Format(timestampFormat) } type Repository struct { Uri string } func NewRepository(repositoryUri string) Repository { return Repository{ Uri: repositoryUri, } } func (repository *Repository) Login(username, password string) { console.Debug("Logging into Docker repository [%s]", repository.Uri) console.Shell("docker login --username %s --password ******* %s", username, repository.Uri) cmd := exec.Command("docker", "login", "--username", username, "--password", password, repository.Uri) if console.Verbose { cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr } if err := cmd.Start(); err != nil { console.ErrorExit(err, "Couldn't login to Docker repository [%s]", repository.Uri) } if err := cmd.Wait(); err != nil { console.IssueExit("Couldn't login to Docker repository [%s]", repository.Uri) } } func (repository *Repository) Build(tag string) { console.Debug("Building Docker image [%s]", repository.UriFor(tag)) console.Shell("docker build --rm=false --tag %s .", repository.UriFor(tag)) cmd := exec.Command("docker", "build", "--tag", repository.Uri+":"+tag, ".") cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Start(); err != nil { console.ErrorExit(err, "Couldn't build Docker image [%s]", repository.UriFor(tag)) } if err := cmd.Wait(); err != nil { console.IssueExit("Couldn't build Docker image [%s]", repository.Uri) } } func (repository *Repository) Push(tag string) { console.Debug("Pushing Docker image [%s]", repository.UriFor(tag)) console.Shell("docker push %s .", repository.UriFor(tag)) cmd := exec.Command("docker", "push", repository.UriFor(tag)) cmd.Stdout = os.Stdout cmd.Stderr = os.Stderr if err := cmd.Start(); err != nil { console.ErrorExit(err, "Couldn't push Docker image [%s]", repository.UriFor(tag)) } if err := cmd.Wait(); err != nil { console.IssueExit("Couldn't push Docker image [%s]", repository.UriFor(tag)) } } func (repository *Repository) UriFor(tag string) string { return repository.Uri + ":" + tag } ================================================ FILE: ec2/eni.go ================================================ package ec2 import ( "github.com/aws/aws-sdk-go/aws" awsec2 "github.com/aws/aws-sdk-go/service/ec2" "github.com/awslabs/fargatecli/console" ) type Eni struct { PublicIpAddress string EniId string SecurityGroupIds []string } func (ec2 SDKClient) DescribeNetworkInterfaces(eniIds []string) map[string]Eni { enis := make(map[string]Eni) resp, err := ec2.client.DescribeNetworkInterfaces( &awsec2.DescribeNetworkInterfacesInput{ NetworkInterfaceIds: aws.StringSlice(eniIds), }, ) if err != nil { console.ErrorExit(err, "Could not describe network interfaces") } for _, e := range resp.NetworkInterfaces { var securityGroupIds []*string for _, group := range e.Groups { securityGroupIds = append(securityGroupIds, group.GroupId) } if e.Association != nil { eni := Eni{ EniId: aws.StringValue(e.NetworkInterfaceId), PublicIpAddress: aws.StringValue(e.Association.PublicIp), SecurityGroupIds: aws.StringValueSlice(securityGroupIds), } enis[eni.EniId] = eni } } return enis } ================================================ FILE: ec2/main.go ================================================ package ec2 //go:generate mockgen -package client -destination=mock/client/client.go github.com/awslabs/fargatecli/ec2 Client //go:generate mockgen -package sdk -source ../vendor/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface.go -destination=mock/sdk/ec2iface.go github.com/aws/aws-sdk-go/service/ec2/ec2iface EC2API import ( "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" ) // Client represents a method for accessing EC2. type Client interface { AuthorizeAllSecurityGroupIngress(string) error CreateDefaultSecurityGroup() (string, error) GetDefaultSecurityGroupID() (string, error) GetDefaultSubnetIDs() ([]string, error) GetSubnetVPCID(string) (string, error) } // SDKClient implements access to EC2 via the AWS SDK. type SDKClient struct { client ec2iface.EC2API } // New returns an SDKClient configured with the given session. func New(sess *session.Session) SDKClient { return SDKClient{ client: ec2.New(sess), } } ================================================ FILE: ec2/mock/client/client.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/awslabs/fargatecli/ec2 (interfaces: Client) // Package client is a generated GoMock package. package client import ( gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } // MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } // NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } // AuthorizeAllSecurityGroupIngress mocks base method func (m *MockClient) AuthorizeAllSecurityGroupIngress(arg0 string) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AuthorizeAllSecurityGroupIngress", arg0) ret0, _ := ret[0].(error) return ret0 } // AuthorizeAllSecurityGroupIngress indicates an expected call of AuthorizeAllSecurityGroupIngress func (mr *MockClientMockRecorder) AuthorizeAllSecurityGroupIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeAllSecurityGroupIngress", reflect.TypeOf((*MockClient)(nil).AuthorizeAllSecurityGroupIngress), arg0) } // CreateDefaultSecurityGroup mocks base method func (m *MockClient) CreateDefaultSecurityGroup() (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateDefaultSecurityGroup") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateDefaultSecurityGroup indicates an expected call of CreateDefaultSecurityGroup func (mr *MockClientMockRecorder) CreateDefaultSecurityGroup() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSecurityGroup", reflect.TypeOf((*MockClient)(nil).CreateDefaultSecurityGroup)) } // GetDefaultSecurityGroupID mocks base method func (m *MockClient) GetDefaultSecurityGroupID() (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDefaultSecurityGroupID") ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDefaultSecurityGroupID indicates an expected call of GetDefaultSecurityGroupID func (mr *MockClientMockRecorder) GetDefaultSecurityGroupID() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultSecurityGroupID", reflect.TypeOf((*MockClient)(nil).GetDefaultSecurityGroupID)) } // GetDefaultSubnetIDs mocks base method func (m *MockClient) GetDefaultSubnetIDs() ([]string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetDefaultSubnetIDs") ret0, _ := ret[0].([]string) ret1, _ := ret[1].(error) return ret0, ret1 } // GetDefaultSubnetIDs indicates an expected call of GetDefaultSubnetIDs func (mr *MockClientMockRecorder) GetDefaultSubnetIDs() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultSubnetIDs", reflect.TypeOf((*MockClient)(nil).GetDefaultSubnetIDs)) } // GetSubnetVPCID mocks base method func (m *MockClient) GetSubnetVPCID(arg0 string) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetSubnetVPCID", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // GetSubnetVPCID indicates an expected call of GetSubnetVPCID func (mr *MockClientMockRecorder) GetSubnetVPCID(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubnetVPCID", reflect.TypeOf((*MockClient)(nil).GetSubnetVPCID), arg0) } ================================================ FILE: ec2/mock/sdk/ec2iface.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: ../vendor/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface.go // Package sdk is a generated GoMock package. package sdk import ( aws "github.com/aws/aws-sdk-go/aws" request "github.com/aws/aws-sdk-go/aws/request" ec2 "github.com/aws/aws-sdk-go/service/ec2" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockEC2API is a mock of EC2API interface type MockEC2API struct { ctrl *gomock.Controller recorder *MockEC2APIMockRecorder } // MockEC2APIMockRecorder is the mock recorder for MockEC2API type MockEC2APIMockRecorder struct { mock *MockEC2API } // NewMockEC2API creates a new mock instance func NewMockEC2API(ctrl *gomock.Controller) *MockEC2API { mock := &MockEC2API{ctrl: ctrl} mock.recorder = &MockEC2APIMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockEC2API) EXPECT() *MockEC2APIMockRecorder { return m.recorder } // AcceptReservedInstancesExchangeQuote mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuote), arg0) } // AcceptReservedInstancesExchangeQuoteWithContext mocks base method func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...) } // AcceptReservedInstancesExchangeQuoteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0) } // AcceptTransitGatewayPeeringAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachment), arg0) } // AcceptTransitGatewayPeeringAttachmentWithContext mocks base method func (m *MockEC2API) AcceptTransitGatewayPeeringAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentWithContext), varargs...) } // AcceptTransitGatewayPeeringAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayPeeringAttachmentRequest), arg0) } // AcceptTransitGatewayVpcAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachment), arg0) } // AcceptTransitGatewayVpcAttachmentWithContext mocks base method func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentWithContext), varargs...) } // AcceptTransitGatewayVpcAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0) } // AcceptVpcEndpointConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnections), arg0) } // AcceptVpcEndpointConnectionsWithContext mocks base method func (m *MockEC2API) AcceptVpcEndpointConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AcceptVpcEndpointConnectionsWithContext), varargs...) } // AcceptVpcEndpointConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsRequest), arg0) } // AcceptVpcPeeringConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnection), arg0) } // AcceptVpcPeeringConnectionWithContext mocks base method func (m *MockEC2API) AcceptVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // AcceptVpcPeeringConnectionWithContext indicates an expected call of AcceptVpcPeeringConnectionWithContext func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionWithContext), varargs...) } // AcceptVpcPeeringConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionRequest), arg0) } // AdvertiseByoipCidr mocks base method func (m *MockEC2API) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0) ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidr), arg0) } // AdvertiseByoipCidrWithContext mocks base method func (m *MockEC2API) AdvertiseByoipCidrWithContext(arg0 aws.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // AdvertiseByoipCidrWithContext indicates an expected call of AdvertiseByoipCidrWithContext func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrWithContext), varargs...) } // AdvertiseByoipCidrRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrRequest), arg0) } // AllocateAddress mocks base method func (m *MockEC2API) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AllocateAddress", arg0) ret0, _ := ret[0].(*ec2.AllocateAddressOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AllocateAddress indicates an expected call of AllocateAddress func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), arg0) } // AllocateAddressWithContext mocks base method func (m *MockEC2API) AllocateAddressWithContext(arg0 aws.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // AllocateAddressWithContext indicates an expected call of AllocateAddressWithContext func (mr *MockEC2APIMockRecorder) AllocateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressWithContext), varargs...) } // AllocateAddressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressRequest), arg0) } // AllocateHosts mocks base method func (m *MockEC2API) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AllocateHosts", arg0) ret0, _ := ret[0].(*ec2.AllocateHostsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AllocateHosts indicates an expected call of AllocateHosts func (mr *MockEC2APIMockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2API)(nil).AllocateHosts), arg0) } // AllocateHostsWithContext mocks base method func (m *MockEC2API) AllocateHostsWithContext(arg0 aws.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // AllocateHostsWithContext indicates an expected call of AllocateHostsWithContext func (mr *MockEC2APIMockRecorder) AllocateHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsWithContext), varargs...) } // AllocateHostsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsRequest), arg0) } // ApplySecurityGroupsToClientVpnTargetNetwork mocks base method func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0) ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0) } // ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 aws.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // ApplySecurityGroupsToClientVpnTargetNetworkWithContext indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkWithContext func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkWithContext), varargs...) } // ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0) } // AssignIpv6Addresses mocks base method func (m *MockEC2API) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0) ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses func (mr *MockEC2APIMockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6Addresses), arg0) } // AssignIpv6AddressesWithContext mocks base method func (m *MockEC2API) AssignIpv6AddressesWithContext(arg0 aws.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // AssignIpv6AddressesWithContext indicates an expected call of AssignIpv6AddressesWithContext func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesWithContext), varargs...) } // AssignIpv6AddressesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesRequest), arg0) } // AssignPrivateIpAddresses mocks base method func (m *MockEC2API) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0) ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddresses), arg0) } // AssignPrivateIpAddressesWithContext mocks base method func (m *MockEC2API) AssignPrivateIpAddressesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssignPrivateIpAddressesWithContext), varargs...) } // AssignPrivateIpAddressesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesRequest), arg0) } // AssociateAddress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), arg0) } // AssociateAddressWithContext mocks base method func (m *MockEC2API) AssociateAddressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateAddressWithContext), varargs...) } // AssociateAddressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressRequest), arg0) } // AssociateClientVpnTargetNetwork mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetwork), arg0) } // AssociateClientVpnTargetNetworkWithContext mocks base method func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateClientVpnTargetNetworkWithContext), varargs...) } // AssociateClientVpnTargetNetworkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkRequest), arg0) } // AssociateDhcpOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptions), arg0) } // AssociateDhcpOptionsWithContext mocks base method func (m *MockEC2API) AssociateDhcpOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateDhcpOptionsWithContext), varargs...) } // AssociateDhcpOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsRequest), arg0) } // AssociateIamInstanceProfile mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfile), arg0) } // AssociateIamInstanceProfileWithContext mocks base method func (m *MockEC2API) AssociateIamInstanceProfileWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateIamInstanceProfileWithContext), varargs...) } // AssociateIamInstanceProfileRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileRequest), arg0) } // AssociateRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), arg0) } // AssociateRouteTableWithContext mocks base method func (m *MockEC2API) AssociateRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateRouteTableWithContext), varargs...) } // AssociateRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableRequest), arg0) } // AssociateSubnetCidrBlock mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlock), arg0) } // AssociateSubnetCidrBlockWithContext mocks base method func (m *MockEC2API) AssociateSubnetCidrBlockWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateSubnetCidrBlockWithContext), varargs...) } // AssociateSubnetCidrBlockRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockRequest), arg0) } // AssociateTransitGatewayMulticastDomain mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomain), arg0) } // AssociateTransitGatewayMulticastDomainWithContext mocks base method func (m *MockEC2API) AssociateTransitGatewayMulticastDomainWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainWithContext), varargs...) } // AssociateTransitGatewayMulticastDomainRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayMulticastDomainRequest), arg0) } // AssociateTransitGatewayRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTable), arg0) } // AssociateTransitGatewayRouteTableWithContext mocks base method func (m *MockEC2API) AssociateTransitGatewayRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...) } // AssociateTransitGatewayRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableRequest), arg0) } // AssociateVpcCidrBlock mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), arg0) } // AssociateVpcCidrBlockWithContext mocks base method func (m *MockEC2API) AssociateVpcCidrBlockWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AssociateVpcCidrBlockWithContext), varargs...) } // AssociateVpcCidrBlockRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockRequest), arg0) } // AttachClassicLinkVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpc), arg0) } // AttachClassicLinkVpcWithContext mocks base method func (m *MockEC2API) AttachClassicLinkVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AttachClassicLinkVpcWithContext), varargs...) } // AttachClassicLinkVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcRequest), arg0) } // AttachInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), arg0) } // AttachInternetGatewayWithContext mocks base method func (m *MockEC2API) AttachInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AttachInternetGatewayWithContext), varargs...) } // AttachInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayRequest), arg0) } // AttachNetworkInterface mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterface), arg0) } // AttachNetworkInterfaceWithContext mocks base method func (m *MockEC2API) AttachNetworkInterfaceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AttachNetworkInterfaceWithContext), varargs...) } // AttachNetworkInterfaceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceRequest), arg0) } // AttachVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2API)(nil).AttachVolume), arg0) } // AttachVolumeWithContext mocks base method func (m *MockEC2API) AttachVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AttachVolumeWithContext), varargs...) } // AttachVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeRequest), arg0) } // AttachVpnGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGateway), arg0) } // AttachVpnGatewayWithContext mocks base method func (m *MockEC2API) AttachVpnGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AttachVpnGatewayWithContext), varargs...) } // AttachVpnGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayRequest), arg0) } // AuthorizeClientVpnIngress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngress), arg0) } // AuthorizeClientVpnIngressWithContext mocks base method func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AuthorizeClientVpnIngressWithContext), varargs...) } // AuthorizeClientVpnIngressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressRequest), arg0) } // AuthorizeSecurityGroupEgress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgress), arg0) } // AuthorizeSecurityGroupEgressWithContext mocks base method func (m *MockEC2API) AuthorizeSecurityGroupEgressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AuthorizeSecurityGroupEgressWithContext), varargs...) } // AuthorizeSecurityGroupEgressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressRequest), arg0) } // AuthorizeSecurityGroupIngress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), arg0) } // AuthorizeSecurityGroupIngressWithContext mocks base method func (m *MockEC2API) AuthorizeSecurityGroupIngressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).AuthorizeSecurityGroupIngressWithContext), varargs...) } // AuthorizeSecurityGroupIngressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressRequest), arg0) } // BundleInstance mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) BundleInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2API)(nil).BundleInstance), arg0) } // BundleInstanceWithContext mocks base method func (m *MockEC2API) BundleInstanceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).BundleInstanceWithContext), varargs...) } // BundleInstanceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceRequest), arg0) } // CancelBundleTask mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTask), arg0) } // CancelBundleTaskWithContext mocks base method func (m *MockEC2API) CancelBundleTaskWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelBundleTaskWithContext), varargs...) } // CancelBundleTaskRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskRequest), arg0) } // CancelCapacityReservation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservation), arg0) } // CancelCapacityReservationWithContext mocks base method func (m *MockEC2API) CancelCapacityReservationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelCapacityReservationWithContext), varargs...) } // CancelCapacityReservationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationRequest), arg0) } // CancelConversionTask mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTask), arg0) } // CancelConversionTaskWithContext mocks base method func (m *MockEC2API) CancelConversionTaskWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelConversionTaskWithContext), varargs...) } // CancelConversionTaskRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskRequest), arg0) } // CancelExportTask mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2API)(nil).CancelExportTask), arg0) } // CancelExportTaskWithContext mocks base method func (m *MockEC2API) CancelExportTaskWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelExportTaskWithContext), varargs...) } // CancelExportTaskRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskRequest), arg0) } // CancelImportTask mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2API)(nil).CancelImportTask), arg0) } // CancelImportTaskWithContext mocks base method func (m *MockEC2API) CancelImportTaskWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelImportTaskWithContext), varargs...) } // CancelImportTaskRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskRequest), arg0) } // CancelReservedInstancesListing mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListing), arg0) } // CancelReservedInstancesListingWithContext mocks base method func (m *MockEC2API) CancelReservedInstancesListingWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelReservedInstancesListingWithContext), varargs...) } // CancelReservedInstancesListingRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingRequest), arg0) } // CancelSpotFleetRequests mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequests), arg0) } // CancelSpotFleetRequestsWithContext mocks base method func (m *MockEC2API) CancelSpotFleetRequestsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelSpotFleetRequestsWithContext), varargs...) } // CancelSpotFleetRequestsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsRequest), arg0) } // CancelSpotInstanceRequests mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequests), arg0) } // CancelSpotInstanceRequestsWithContext mocks base method func (m *MockEC2API) CancelSpotInstanceRequestsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CancelSpotInstanceRequestsWithContext), varargs...) } // CancelSpotInstanceRequestsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsRequest), arg0) } // ConfirmProductInstance mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstance), arg0) } // ConfirmProductInstanceWithContext mocks base method func (m *MockEC2API) ConfirmProductInstanceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ConfirmProductInstanceWithContext), varargs...) } // ConfirmProductInstanceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceRequest), arg0) } // CopyFpgaImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImage), arg0) } // CopyFpgaImageWithContext mocks base method func (m *MockEC2API) CopyFpgaImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CopyFpgaImageWithContext), varargs...) } // CopyFpgaImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageRequest), arg0) } // CopyImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopyImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2API)(nil).CopyImage), arg0) } // CopyImageWithContext mocks base method func (m *MockEC2API) CopyImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CopyImageWithContext), varargs...) } // CopyImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyImageRequest), arg0) } // CopySnapshot mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2API)(nil).CopySnapshot), arg0) } // CopySnapshotWithContext mocks base method func (m *MockEC2API) CopySnapshotWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CopySnapshotWithContext), varargs...) } // CopySnapshotRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotRequest), arg0) } // CreateCapacityReservation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservation), arg0) } // CreateCapacityReservationWithContext mocks base method func (m *MockEC2API) CreateCapacityReservationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateCapacityReservationWithContext), varargs...) } // CreateCapacityReservationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationRequest), arg0) } // CreateClientVpnEndpoint mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpoint), arg0) } // CreateClientVpnEndpointWithContext mocks base method func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateClientVpnEndpointWithContext), varargs...) } // CreateClientVpnEndpointRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointRequest), arg0) } // CreateClientVpnRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRoute), arg0) } // CreateClientVpnRouteWithContext mocks base method func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateClientVpnRouteWithContext), varargs...) } // CreateClientVpnRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteRequest), arg0) } // CreateCustomerGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGateway), arg0) } // CreateCustomerGatewayWithContext mocks base method func (m *MockEC2API) CreateCustomerGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateCustomerGatewayWithContext), varargs...) } // CreateCustomerGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayRequest), arg0) } // CreateDefaultSubnet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnet), arg0) } // CreateDefaultSubnetWithContext mocks base method func (m *MockEC2API) CreateDefaultSubnetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateDefaultSubnetWithContext), varargs...) } // CreateDefaultSubnetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetRequest), arg0) } // CreateDefaultVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpc), arg0) } // CreateDefaultVpcWithContext mocks base method func (m *MockEC2API) CreateDefaultVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateDefaultVpcWithContext), varargs...) } // CreateDefaultVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcRequest), arg0) } // CreateDhcpOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptions), arg0) } // CreateDhcpOptionsWithContext mocks base method func (m *MockEC2API) CreateDhcpOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateDhcpOptionsWithContext), varargs...) } // CreateDhcpOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsRequest), arg0) } // CreateEgressOnlyInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), arg0) } // CreateEgressOnlyInternetGatewayWithContext mocks base method func (m *MockEC2API) CreateEgressOnlyInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayWithContext), varargs...) } // CreateEgressOnlyInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayRequest), arg0) } // CreateFleet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2API)(nil).CreateFleet), arg0) } // CreateFleetWithContext mocks base method func (m *MockEC2API) CreateFleetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateFleetWithContext), varargs...) } // CreateFleetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFleetRequest), arg0) } // CreateFlowLogs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogs), arg0) } // CreateFlowLogsWithContext mocks base method func (m *MockEC2API) CreateFlowLogsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateFlowLogsWithContext), varargs...) } // CreateFlowLogsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsRequest), arg0) } // CreateFpgaImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImage), arg0) } // CreateFpgaImageWithContext mocks base method func (m *MockEC2API) CreateFpgaImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateFpgaImageWithContext), varargs...) } // CreateFpgaImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageRequest), arg0) } // CreateImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2API)(nil).CreateImage), arg0) } // CreateImageWithContext mocks base method func (m *MockEC2API) CreateImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateImageWithContext), varargs...) } // CreateImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateImageRequest), arg0) } // CreateInstanceExportTask mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTask), arg0) } // CreateInstanceExportTaskWithContext mocks base method func (m *MockEC2API) CreateInstanceExportTaskWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateInstanceExportTaskWithContext), varargs...) } // CreateInstanceExportTaskRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskRequest), arg0) } // CreateInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), arg0) } // CreateInternetGatewayWithContext mocks base method func (m *MockEC2API) CreateInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateInternetGatewayWithContext), varargs...) } // CreateInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayRequest), arg0) } // CreateKeyPair mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPair), arg0) } // CreateKeyPairWithContext mocks base method func (m *MockEC2API) CreateKeyPairWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateKeyPairWithContext), varargs...) } // CreateKeyPairRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairRequest), arg0) } // CreateLaunchTemplate mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), arg0) } // CreateLaunchTemplateWithContext mocks base method func (m *MockEC2API) CreateLaunchTemplateWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateLaunchTemplateWithContext), varargs...) } // CreateLaunchTemplateRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateRequest), arg0) } // CreateLaunchTemplateVersion mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), arg0) } // CreateLaunchTemplateVersionWithContext mocks base method func (m *MockEC2API) CreateLaunchTemplateVersionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateLaunchTemplateVersionWithContext), varargs...) } // CreateLaunchTemplateVersionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionRequest), arg0) } // CreateLocalGatewayRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLocalGatewayRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRoute), arg0) } // CreateLocalGatewayRouteWithContext mocks base method func (m *MockEC2API) CreateLocalGatewayRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateLocalGatewayRouteWithContext), varargs...) } // CreateLocalGatewayRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteRequest), arg0) } // CreateLocalGatewayRouteTableVpcAssociation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociation), arg0) } // CreateLocalGatewayRouteTableVpcAssociationWithContext mocks base method func (m *MockEC2API) CreateLocalGatewayRouteTableVpcAssociationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationWithContext), varargs...) } // CreateLocalGatewayRouteTableVpcAssociationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLocalGatewayRouteTableVpcAssociationRequest), arg0) } // CreateNatGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), arg0) } // CreateNatGatewayWithContext mocks base method func (m *MockEC2API) CreateNatGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateNatGatewayWithContext), varargs...) } // CreateNatGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayRequest), arg0) } // CreateNetworkAcl mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAcl), arg0) } // CreateNetworkAclWithContext mocks base method func (m *MockEC2API) CreateNetworkAclWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateNetworkAclWithContext), varargs...) } // CreateNetworkAclRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclRequest), arg0) } // CreateNetworkAclEntry mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntry), arg0) } // CreateNetworkAclEntryWithContext mocks base method func (m *MockEC2API) CreateNetworkAclEntryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateNetworkAclEntryWithContext), varargs...) } // CreateNetworkAclEntryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryRequest), arg0) } // CreateNetworkInterface mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterface), arg0) } // CreateNetworkInterfaceWithContext mocks base method func (m *MockEC2API) CreateNetworkInterfaceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateNetworkInterfaceWithContext), varargs...) } // CreateNetworkInterfaceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceRequest), arg0) } // CreateNetworkInterfacePermission mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermission), arg0) } // CreateNetworkInterfacePermissionWithContext mocks base method func (m *MockEC2API) CreateNetworkInterfacePermissionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateNetworkInterfacePermissionWithContext), varargs...) } // CreateNetworkInterfacePermissionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionRequest), arg0) } // CreatePlacementGroup mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroup), arg0) } // CreatePlacementGroupWithContext mocks base method func (m *MockEC2API) CreatePlacementGroupWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...) } // CreatePlacementGroupRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupRequest), arg0) } // CreateReservedInstancesListing mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListing), arg0) } // CreateReservedInstancesListingWithContext mocks base method func (m *MockEC2API) CreateReservedInstancesListingWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateReservedInstancesListingWithContext), varargs...) } // CreateReservedInstancesListingRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingRequest), arg0) } // CreateRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), arg0) } // CreateRouteWithContext mocks base method func (m *MockEC2API) CreateRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateRouteWithContext), varargs...) } // CreateRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteRequest), arg0) } // CreateRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), arg0) } // CreateRouteTableWithContext mocks base method func (m *MockEC2API) CreateRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateRouteTableWithContext), varargs...) } // CreateRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableRequest), arg0) } // CreateSecurityGroup mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), arg0) } // CreateSecurityGroupWithContext mocks base method func (m *MockEC2API) CreateSecurityGroupWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateSecurityGroupWithContext), varargs...) } // CreateSecurityGroupRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupRequest), arg0) } // CreateSnapshot mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshot), arg0) } // CreateSnapshotWithContext mocks base method func (m *MockEC2API) CreateSnapshotWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateSnapshotWithContext), varargs...) } // CreateSnapshotRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotRequest), arg0) } // CreateSnapshots mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshots), arg0) } // CreateSnapshotsWithContext mocks base method func (m *MockEC2API) CreateSnapshotsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateSnapshotsWithContext), varargs...) } // CreateSnapshotsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsRequest), arg0) } // CreateSpotDatafeedSubscription mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscription), arg0) } // CreateSpotDatafeedSubscriptionWithContext mocks base method func (m *MockEC2API) CreateSpotDatafeedSubscriptionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...) } // CreateSpotDatafeedSubscriptionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionRequest), arg0) } // CreateSubnet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), arg0) } // CreateSubnetWithContext mocks base method func (m *MockEC2API) CreateSubnetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateSubnetWithContext), varargs...) } // CreateSubnetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetRequest), arg0) } // CreateTags mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), arg0) } // CreateTagsWithContext mocks base method func (m *MockEC2API) CreateTagsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTagsWithContext), varargs...) } // CreateTagsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTagsRequest), arg0) } // CreateTrafficMirrorFilter mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0) } // CreateTrafficMirrorFilterWithContext mocks base method func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTrafficMirrorFilterWithContext), varargs...) } // CreateTrafficMirrorFilterRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0) } // CreateTrafficMirrorFilterRule mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0) } // CreateTrafficMirrorFilterRuleWithContext mocks base method func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...) } // CreateTrafficMirrorFilterRuleRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0) } // CreateTrafficMirrorSession mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0) } // CreateTrafficMirrorSessionWithContext mocks base method func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTrafficMirrorSessionWithContext), varargs...) } // CreateTrafficMirrorSessionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0) } // CreateTrafficMirrorTarget mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0) } // CreateTrafficMirrorTargetWithContext mocks base method func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTrafficMirrorTargetWithContext), varargs...) } // CreateTrafficMirrorTargetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetRequest), arg0) } // CreateTransitGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0) } // CreateTransitGatewayWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTransitGatewayWithContext), varargs...) } // CreateTransitGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0) } // CreateTransitGatewayMulticastDomain mocks base method func (m *MockEC2API) CreateTransitGatewayMulticastDomain(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomain", arg0) ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTransitGatewayMulticastDomain indicates an expected call of CreateTransitGatewayMulticastDomain func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomain), arg0) } // CreateTransitGatewayMulticastDomainWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayMulticastDomainWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayMulticastDomainInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayMulticastDomainOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainWithContext", varargs...) ret0, _ := ret[0].(*ec2.CreateTransitGatewayMulticastDomainOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTransitGatewayMulticastDomainWithContext indicates an expected call of CreateTransitGatewayMulticastDomainWithContext func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainWithContext), varargs...) } // CreateTransitGatewayMulticastDomainRequest mocks base method func (m *MockEC2API) CreateTransitGatewayMulticastDomainRequest(arg0 *ec2.CreateTransitGatewayMulticastDomainInput) (*request.Request, *ec2.CreateTransitGatewayMulticastDomainOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTransitGatewayMulticastDomainRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.CreateTransitGatewayMulticastDomainOutput) return ret0, ret1 } // CreateTransitGatewayMulticastDomainRequest indicates an expected call of CreateTransitGatewayMulticastDomainRequest func (mr *MockEC2APIMockRecorder) CreateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayMulticastDomainRequest), arg0) } // CreateTransitGatewayPeeringAttachment mocks base method func (m *MockEC2API) CreateTransitGatewayPeeringAttachment(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachment", arg0) ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTransitGatewayPeeringAttachment indicates an expected call of CreateTransitGatewayPeeringAttachment func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachment), arg0) } // CreateTransitGatewayPeeringAttachmentWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayPeeringAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayPeeringAttachmentOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentWithContext", varargs...) ret0, _ := ret[0].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTransitGatewayPeeringAttachmentWithContext indicates an expected call of CreateTransitGatewayPeeringAttachmentWithContext func (mr *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentWithContext), varargs...) } // CreateTransitGatewayPeeringAttachmentRequest mocks base method func (m *MockEC2API) CreateTransitGatewayPeeringAttachmentRequest(arg0 *ec2.CreateTransitGatewayPeeringAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayPeeringAttachmentOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTransitGatewayPeeringAttachmentRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.CreateTransitGatewayPeeringAttachmentOutput) return ret0, ret1 } // CreateTransitGatewayPeeringAttachmentRequest indicates an expected call of CreateTransitGatewayPeeringAttachmentRequest func (mr *MockEC2APIMockRecorder) CreateTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayPeeringAttachmentRequest), arg0) } // CreateTransitGatewayRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0) } // CreateTransitGatewayRouteWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTransitGatewayRouteWithContext), varargs...) } // CreateTransitGatewayRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0) } // CreateTransitGatewayRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0) } // CreateTransitGatewayRouteTableWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTransitGatewayRouteTableWithContext), varargs...) } // CreateTransitGatewayRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0) } // CreateTransitGatewayVpcAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0) } // CreateTransitGatewayVpcAttachmentWithContext mocks base method func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...) } // CreateTransitGatewayVpcAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0) } // CreateVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2API)(nil).CreateVolume), arg0) } // CreateVolumeWithContext mocks base method func (m *MockEC2API) CreateVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVolumeWithContext), varargs...) } // CreateVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeRequest), arg0) } // CreateVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), arg0) } // CreateVpcWithContext mocks base method func (m *MockEC2API) CreateVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpcWithContext), varargs...) } // CreateVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcRequest), arg0) } // CreateVpcEndpoint mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), arg0) } // CreateVpcEndpointWithContext mocks base method func (m *MockEC2API) CreateVpcEndpointWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpcEndpointWithContext), varargs...) } // CreateVpcEndpointRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointRequest), arg0) } // CreateVpcEndpointConnectionNotification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotification), arg0) } // CreateVpcEndpointConnectionNotificationWithContext mocks base method func (m *MockEC2API) CreateVpcEndpointConnectionNotificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationWithContext), varargs...) } // CreateVpcEndpointConnectionNotificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0) } // CreateVpcEndpointServiceConfiguration mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfiguration), arg0) } // CreateVpcEndpointServiceConfigurationWithContext mocks base method func (m *MockEC2API) CreateVpcEndpointServiceConfigurationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationWithContext), varargs...) } // CreateVpcEndpointServiceConfigurationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0) } // CreateVpcPeeringConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnection), arg0) } // CreateVpcPeeringConnectionWithContext mocks base method func (m *MockEC2API) CreateVpcPeeringConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpcPeeringConnectionWithContext), varargs...) } // CreateVpcPeeringConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionRequest), arg0) } // CreateVpnConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnection), arg0) } // CreateVpnConnectionWithContext mocks base method func (m *MockEC2API) CreateVpnConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpnConnectionWithContext), varargs...) } // CreateVpnConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRequest), arg0) } // CreateVpnConnectionRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRoute), arg0) } // CreateVpnConnectionRouteWithContext mocks base method func (m *MockEC2API) CreateVpnConnectionRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpnConnectionRouteWithContext), varargs...) } // CreateVpnConnectionRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteRequest), arg0) } // CreateVpnGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGateway), arg0) } // CreateVpnGatewayWithContext mocks base method func (m *MockEC2API) CreateVpnGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).CreateVpnGatewayWithContext), varargs...) } // CreateVpnGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayRequest), arg0) } // DeleteClientVpnEndpoint mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpoint), arg0) } // DeleteClientVpnEndpointWithContext mocks base method func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteClientVpnEndpointWithContext), varargs...) } // DeleteClientVpnEndpointRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointRequest), arg0) } // DeleteClientVpnRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRoute), arg0) } // DeleteClientVpnRouteWithContext mocks base method func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteClientVpnRouteWithContext), varargs...) } // DeleteClientVpnRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteRequest), arg0) } // DeleteCustomerGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGateway), arg0) } // DeleteCustomerGatewayWithContext mocks base method func (m *MockEC2API) DeleteCustomerGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteCustomerGatewayWithContext), varargs...) } // DeleteCustomerGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayRequest), arg0) } // DeleteDhcpOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptions), arg0) } // DeleteDhcpOptionsWithContext mocks base method func (m *MockEC2API) DeleteDhcpOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteDhcpOptionsWithContext), varargs...) } // DeleteDhcpOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsRequest), arg0) } // DeleteEgressOnlyInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), arg0) } // DeleteEgressOnlyInternetGatewayWithContext mocks base method func (m *MockEC2API) DeleteEgressOnlyInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayWithContext), varargs...) } // DeleteEgressOnlyInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0) } // DeleteFleets mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2API)(nil).DeleteFleets), arg0) } // DeleteFleetsWithContext mocks base method func (m *MockEC2API) DeleteFleetsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteFleetsWithContext), varargs...) } // DeleteFleetsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsRequest), arg0) } // DeleteFlowLogs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogs), arg0) } // DeleteFlowLogsWithContext mocks base method func (m *MockEC2API) DeleteFlowLogsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteFlowLogsWithContext), varargs...) } // DeleteFlowLogsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsRequest), arg0) } // DeleteFpgaImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImage), arg0) } // DeleteFpgaImageWithContext mocks base method func (m *MockEC2API) DeleteFpgaImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteFpgaImageWithContext), varargs...) } // DeleteFpgaImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageRequest), arg0) } // DeleteInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), arg0) } // DeleteInternetGatewayWithContext mocks base method func (m *MockEC2API) DeleteInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteInternetGatewayWithContext), varargs...) } // DeleteInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayRequest), arg0) } // DeleteKeyPair mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPair), arg0) } // DeleteKeyPairWithContext mocks base method func (m *MockEC2API) DeleteKeyPairWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteKeyPairWithContext), varargs...) } // DeleteKeyPairRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairRequest), arg0) } // DeleteLaunchTemplate mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), arg0) } // DeleteLaunchTemplateWithContext mocks base method func (m *MockEC2API) DeleteLaunchTemplateWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteLaunchTemplateWithContext), varargs...) } // DeleteLaunchTemplateRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateRequest), arg0) } // DeleteLaunchTemplateVersions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), arg0) } // DeleteLaunchTemplateVersionsWithContext mocks base method func (m *MockEC2API) DeleteLaunchTemplateVersionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteLaunchTemplateVersionsWithContext), varargs...) } // DeleteLaunchTemplateVersionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsRequest), arg0) } // DeleteLocalGatewayRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLocalGatewayRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRoute), arg0) } // DeleteLocalGatewayRouteWithContext mocks base method func (m *MockEC2API) DeleteLocalGatewayRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteLocalGatewayRouteWithContext), varargs...) } // DeleteLocalGatewayRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLocalGatewayRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteRequest), arg0) } // DeleteLocalGatewayRouteTableVpcAssociation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociation", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociation), arg0) } // DeleteLocalGatewayRouteTableVpcAssociationWithContext mocks base method func (m *MockEC2API) DeleteLocalGatewayRouteTableVpcAssociationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationWithContext), varargs...) } // DeleteLocalGatewayRouteTableVpcAssociationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteLocalGatewayRouteTableVpcAssociationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLocalGatewayRouteTableVpcAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLocalGatewayRouteTableVpcAssociationRequest), arg0) } // DeleteNatGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), arg0) } // DeleteNatGatewayWithContext mocks base method func (m *MockEC2API) DeleteNatGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteNatGatewayWithContext), varargs...) } // DeleteNatGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayRequest), arg0) } // DeleteNetworkAcl mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAcl), arg0) } // DeleteNetworkAclWithContext mocks base method func (m *MockEC2API) DeleteNetworkAclWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteNetworkAclWithContext), varargs...) } // DeleteNetworkAclRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclRequest), arg0) } // DeleteNetworkAclEntry mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntry), arg0) } // DeleteNetworkAclEntryWithContext mocks base method func (m *MockEC2API) DeleteNetworkAclEntryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteNetworkAclEntryWithContext), varargs...) } // DeleteNetworkAclEntryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryRequest), arg0) } // DeleteNetworkInterface mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterface), arg0) } // DeleteNetworkInterfaceWithContext mocks base method func (m *MockEC2API) DeleteNetworkInterfaceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteNetworkInterfaceWithContext), varargs...) } // DeleteNetworkInterfaceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceRequest), arg0) } // DeleteNetworkInterfacePermission mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermission), arg0) } // DeleteNetworkInterfacePermissionWithContext mocks base method func (m *MockEC2API) DeleteNetworkInterfacePermissionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteNetworkInterfacePermissionWithContext), varargs...) } // DeleteNetworkInterfacePermissionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionRequest), arg0) } // DeletePlacementGroup mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroup), arg0) } // DeletePlacementGroupWithContext mocks base method func (m *MockEC2API) DeletePlacementGroupWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeletePlacementGroupWithContext), varargs...) } // DeletePlacementGroupRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupRequest), arg0) } // DeleteQueuedReservedInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteQueuedReservedInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstances), arg0) } // DeleteQueuedReservedInstancesWithContext mocks base method func (m *MockEC2API) DeleteQueuedReservedInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteQueuedReservedInstancesWithContext), varargs...) } // DeleteQueuedReservedInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteQueuedReservedInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueuedReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteQueuedReservedInstancesRequest), arg0) } // DeleteRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteRoute), arg0) } // DeleteRouteWithContext mocks base method func (m *MockEC2API) DeleteRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteRouteWithContext), varargs...) } // DeleteRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteRequest), arg0) } // DeleteRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), arg0) } // DeleteRouteTableWithContext mocks base method func (m *MockEC2API) DeleteRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteRouteTableWithContext), varargs...) } // DeleteRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableRequest), arg0) } // DeleteSecurityGroup mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), arg0) } // DeleteSecurityGroupWithContext mocks base method func (m *MockEC2API) DeleteSecurityGroupWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteSecurityGroupWithContext), varargs...) } // DeleteSecurityGroupRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupRequest), arg0) } // DeleteSnapshot mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshot), arg0) } // DeleteSnapshotWithContext mocks base method func (m *MockEC2API) DeleteSnapshotWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteSnapshotWithContext), varargs...) } // DeleteSnapshotRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotRequest), arg0) } // DeleteSpotDatafeedSubscription mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscription), arg0) } // DeleteSpotDatafeedSubscriptionWithContext mocks base method func (m *MockEC2API) DeleteSpotDatafeedSubscriptionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionWithContext), varargs...) } // DeleteSpotDatafeedSubscriptionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0) } // DeleteSubnet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), arg0) } // DeleteSubnetWithContext mocks base method func (m *MockEC2API) DeleteSubnetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteSubnetWithContext), varargs...) } // DeleteSubnetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetRequest), arg0) } // DeleteTags mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), arg0) } // DeleteTagsWithContext mocks base method func (m *MockEC2API) DeleteTagsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTagsWithContext), varargs...) } // DeleteTagsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsRequest), arg0) } // DeleteTrafficMirrorFilter mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilter), arg0) } // DeleteTrafficMirrorFilterWithContext mocks base method func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTrafficMirrorFilterWithContext), varargs...) } // DeleteTrafficMirrorFilterRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRequest), arg0) } // DeleteTrafficMirrorFilterRule mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRule), arg0) } // DeleteTrafficMirrorFilterRuleWithContext mocks base method func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleWithContext), varargs...) } // DeleteTrafficMirrorFilterRuleRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0) } // DeleteTrafficMirrorSession mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSession), arg0) } // DeleteTrafficMirrorSessionWithContext mocks base method func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTrafficMirrorSessionWithContext), varargs...) } // DeleteTrafficMirrorSessionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionRequest), arg0) } // DeleteTrafficMirrorTarget mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTarget), arg0) } // DeleteTrafficMirrorTargetWithContext mocks base method func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTrafficMirrorTargetWithContext), varargs...) } // DeleteTrafficMirrorTargetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetRequest), arg0) } // DeleteTransitGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0) } // DeleteTransitGatewayWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayWithContext), varargs...) } // DeleteTransitGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRequest), arg0) } // DeleteTransitGatewayMulticastDomain mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomain), arg0) } // DeleteTransitGatewayMulticastDomainWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayMulticastDomainWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainWithContext), varargs...) } // DeleteTransitGatewayMulticastDomainRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayMulticastDomainRequest), arg0) } // DeleteTransitGatewayPeeringAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachment), arg0) } // DeleteTransitGatewayPeeringAttachmentWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayPeeringAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentWithContext), varargs...) } // DeleteTransitGatewayPeeringAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayPeeringAttachmentRequest), arg0) } // DeleteTransitGatewayRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRoute), arg0) } // DeleteTransitGatewayRouteWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayRouteWithContext), varargs...) } // DeleteTransitGatewayRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteRequest), arg0) } // DeleteTransitGatewayRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTable), arg0) } // DeleteTransitGatewayRouteTableWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayRouteTableWithContext), varargs...) } // DeleteTransitGatewayRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableRequest), arg0) } // DeleteTransitGatewayVpcAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachment), arg0) } // DeleteTransitGatewayVpcAttachmentWithContext mocks base method func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentWithContext), varargs...) } // DeleteTransitGatewayVpcAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0) } // DeleteVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2API)(nil).DeleteVolume), arg0) } // DeleteVolumeWithContext mocks base method func (m *MockEC2API) DeleteVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVolumeWithContext), varargs...) } // DeleteVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeRequest), arg0) } // DeleteVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), arg0) } // DeleteVpcWithContext mocks base method func (m *MockEC2API) DeleteVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpcWithContext), varargs...) } // DeleteVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcRequest), arg0) } // DeleteVpcEndpointConnectionNotifications mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotifications), arg0) } // DeleteVpcEndpointConnectionNotificationsWithContext mocks base method func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsWithContext), varargs...) } // DeleteVpcEndpointConnectionNotificationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0) } // DeleteVpcEndpointServiceConfigurations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurations), arg0) } // DeleteVpcEndpointServiceConfigurationsWithContext mocks base method func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsWithContext), varargs...) } // DeleteVpcEndpointServiceConfigurationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0) } // DeleteVpcEndpoints mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), arg0) } // DeleteVpcEndpointsWithContext mocks base method func (m *MockEC2API) DeleteVpcEndpointsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpcEndpointsWithContext), varargs...) } // DeleteVpcEndpointsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsRequest), arg0) } // DeleteVpcPeeringConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnection), arg0) } // DeleteVpcPeeringConnectionWithContext mocks base method func (m *MockEC2API) DeleteVpcPeeringConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpcPeeringConnectionWithContext), varargs...) } // DeleteVpcPeeringConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionRequest), arg0) } // DeleteVpnConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnection), arg0) } // DeleteVpnConnectionWithContext mocks base method func (m *MockEC2API) DeleteVpnConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpnConnectionWithContext), varargs...) } // DeleteVpnConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRequest), arg0) } // DeleteVpnConnectionRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRoute), arg0) } // DeleteVpnConnectionRouteWithContext mocks base method func (m *MockEC2API) DeleteVpnConnectionRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpnConnectionRouteWithContext), varargs...) } // DeleteVpnConnectionRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteRequest), arg0) } // DeleteVpnGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGateway), arg0) } // DeleteVpnGatewayWithContext mocks base method func (m *MockEC2API) DeleteVpnGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeleteVpnGatewayWithContext), varargs...) } // DeleteVpnGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayRequest), arg0) } // DeprovisionByoipCidr mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidr), arg0) } // DeprovisionByoipCidrWithContext mocks base method func (m *MockEC2API) DeprovisionByoipCidrWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeprovisionByoipCidrWithContext), varargs...) } // DeprovisionByoipCidrRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrRequest), arg0) } // DeregisterImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2API)(nil).DeregisterImage), arg0) } // DeregisterImageWithContext mocks base method func (m *MockEC2API) DeregisterImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeregisterImageWithContext), varargs...) } // DeregisterImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageRequest), arg0) } // DeregisterInstanceEventNotificationAttributes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributes), arg0) } // DeregisterInstanceEventNotificationAttributesWithContext mocks base method func (m *MockEC2API) DeregisterInstanceEventNotificationAttributesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesWithContext), varargs...) } // DeregisterInstanceEventNotificationAttributesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterInstanceEventNotificationAttributesRequest), arg0) } // DeregisterTransitGatewayMulticastGroupMembers mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembers), arg0) } // DeregisterTransitGatewayMulticastGroupMembersWithContext mocks base method func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupMembersWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersWithContext), varargs...) } // DeregisterTransitGatewayMulticastGroupMembersRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupMembersRequest), arg0) } // DeregisterTransitGatewayMulticastGroupSources mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSources), arg0) } // DeregisterTransitGatewayMulticastGroupSourcesWithContext mocks base method func (m *MockEC2API) DeregisterTransitGatewayMulticastGroupSourcesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) } // DeregisterTransitGatewayMulticastGroupSourcesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DeregisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterTransitGatewayMulticastGroupSourcesRequest), arg0) } // DescribeAccountAttributes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributes), arg0) } // DescribeAccountAttributesWithContext mocks base method func (m *MockEC2API) DescribeAccountAttributesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeAccountAttributesWithContext), varargs...) } // DescribeAccountAttributesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesRequest), arg0) } // DescribeAddresses mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0) } // DescribeAddressesWithContext mocks base method func (m *MockEC2API) DescribeAddressesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...) ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...) } // DescribeAddressesRequest mocks base method func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.DescribeAddressesOutput) return ret0, ret1 } // DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0) } // DescribeAggregateIdFormat mocks base method func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0) ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0) } // DescribeAggregateIdFormatWithContext mocks base method func (m *MockEC2API) DescribeAggregateIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeAggregateIdFormatWithContext), varargs...) } // DescribeAggregateIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatRequest), arg0) } // DescribeAvailabilityZones mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), arg0) } // DescribeAvailabilityZonesWithContext mocks base method func (m *MockEC2API) DescribeAvailabilityZonesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeAvailabilityZonesWithContext), varargs...) } // DescribeAvailabilityZonesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesRequest), arg0) } // DescribeBundleTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasks), arg0) } // DescribeBundleTasksWithContext mocks base method func (m *MockEC2API) DescribeBundleTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeBundleTasksWithContext), varargs...) } // DescribeBundleTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksRequest), arg0) } // DescribeByoipCidrs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrs), arg0) } // DescribeByoipCidrsWithContext mocks base method func (m *MockEC2API) DescribeByoipCidrsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeByoipCidrsWithContext), varargs...) } // DescribeByoipCidrsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsRequest), arg0) } // DescribeByoipCidrsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPages), arg0, arg1) } // DescribeByoipCidrsPagesWithContext mocks base method func (m *MockEC2API) DescribeByoipCidrsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeByoipCidrsPagesWithContext), varargs...) } // DescribeCapacityReservations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservations), arg0) } // DescribeCapacityReservationsWithContext mocks base method func (m *MockEC2API) DescribeCapacityReservationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeCapacityReservationsWithContext), varargs...) } // DescribeCapacityReservationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsRequest), arg0) } // DescribeCapacityReservationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPages), arg0, arg1) } // DescribeCapacityReservationsPagesWithContext mocks base method func (m *MockEC2API) DescribeCapacityReservationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeCapacityReservationsPagesWithContext), varargs...) } // DescribeClassicLinkInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstances), arg0) } // DescribeClassicLinkInstancesWithContext mocks base method func (m *MockEC2API) DescribeClassicLinkInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClassicLinkInstancesWithContext), varargs...) } // DescribeClassicLinkInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesRequest), arg0) } // DescribeClassicLinkInstancesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPages), arg0, arg1) } // DescribeClassicLinkInstancesPagesWithContext mocks base method func (m *MockEC2API) DescribeClassicLinkInstancesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClassicLinkInstancesPagesWithContext), varargs...) } // DescribeClientVpnAuthorizationRules mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0) } // DescribeClientVpnAuthorizationRulesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...) } // DescribeClientVpnAuthorizationRulesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0) } // DescribeClientVpnAuthorizationRulesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1) } // DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...) } // DescribeClientVpnConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0) } // DescribeClientVpnConnectionsWithContext mocks base method func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnConnectionsWithContext), varargs...) } // DescribeClientVpnConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0) } // DescribeClientVpnConnectionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1) } // DescribeClientVpnConnectionsPagesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnConnectionsPagesWithContext), varargs...) } // DescribeClientVpnEndpoints mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpoints), arg0) } // DescribeClientVpnEndpointsWithContext mocks base method func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnEndpointsWithContext), varargs...) } // DescribeClientVpnEndpointsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsRequest), arg0) } // DescribeClientVpnEndpointsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPages), arg0, arg1) } // DescribeClientVpnEndpointsPagesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnEndpointsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnEndpointsPagesWithContext), varargs...) } // DescribeClientVpnRoutes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutes), arg0) } // DescribeClientVpnRoutesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnRoutesWithContext), varargs...) } // DescribeClientVpnRoutesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesRequest), arg0) } // DescribeClientVpnRoutesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPages), arg0, arg1) } // DescribeClientVpnRoutesPagesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnRoutesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnRoutesPagesWithContext), varargs...) } // DescribeClientVpnTargetNetworks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworks), arg0) } // DescribeClientVpnTargetNetworksWithContext mocks base method func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnTargetNetworksWithContext), varargs...) } // DescribeClientVpnTargetNetworksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksRequest), arg0) } // DescribeClientVpnTargetNetworksPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1) } // DescribeClientVpnTargetNetworksPagesWithContext mocks base method func (m *MockEC2API) DescribeClientVpnTargetNetworksPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPagesWithContext), varargs...) } // DescribeCoipPools mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCoipPools(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPools", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPools), arg0) } // DescribeCoipPoolsWithContext mocks base method func (m *MockEC2API) DescribeCoipPoolsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeCoipPoolsWithContext), varargs...) } // DescribeCoipPoolsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCoipPoolsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsRequest), arg0) } // DescribeCoipPoolsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCoipPoolsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCoipPoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCoipPoolsPages), arg0, arg1) } // DescribeCoipPoolsPagesWithContext mocks base method func (m *MockEC2API) DescribeCoipPoolsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeCoipPoolsPagesWithContext), varargs...) } // DescribeConversionTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0) } // DescribeConversionTasksWithContext mocks base method func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeConversionTasksWithContext), varargs...) } // DescribeConversionTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0) } // DescribeCustomerGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0) } // DescribeCustomerGatewaysWithContext mocks base method func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeCustomerGatewaysWithContext), varargs...) } // DescribeCustomerGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0) } // DescribeDhcpOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0) } // DescribeDhcpOptionsWithContext mocks base method func (m *MockEC2API) DescribeDhcpOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeDhcpOptionsWithContext), varargs...) } // DescribeDhcpOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsRequest), arg0) } // DescribeDhcpOptionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPages), arg0, arg1) } // DescribeDhcpOptionsPagesWithContext mocks base method func (m *MockEC2API) DescribeDhcpOptionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeDhcpOptionsPagesWithContext), varargs...) } // DescribeEgressOnlyInternetGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), arg0) } // DescribeEgressOnlyInternetGatewaysWithContext mocks base method func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysWithContext), varargs...) } // DescribeEgressOnlyInternetGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0) } // DescribeEgressOnlyInternetGatewaysPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1) } // DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPagesWithContext), varargs...) } // DescribeElasticGpus mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpus), arg0) } // DescribeElasticGpusWithContext mocks base method func (m *MockEC2API) DescribeElasticGpusWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeElasticGpusWithContext), varargs...) } // DescribeElasticGpusRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusRequest), arg0) } // DescribeExportImageTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasks), arg0) } // DescribeExportImageTasksWithContext mocks base method func (m *MockEC2API) DescribeExportImageTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeExportImageTasksWithContext), varargs...) } // DescribeExportImageTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksRequest), arg0) } // DescribeExportImageTasksPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeExportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksPages), arg0, arg1) } // DescribeExportImageTasksPagesWithContext mocks base method func (m *MockEC2API) DescribeExportImageTasksPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeExportImageTasksPagesWithContext), varargs...) } // DescribeExportTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasks), arg0) } // DescribeExportTasksWithContext mocks base method func (m *MockEC2API) DescribeExportTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeExportTasksWithContext), varargs...) } // DescribeExportTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksRequest), arg0) } // DescribeFastSnapshotRestores mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFastSnapshotRestores(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestores), arg0) } // DescribeFastSnapshotRestoresWithContext mocks base method func (m *MockEC2API) DescribeFastSnapshotRestoresWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFastSnapshotRestoresWithContext), varargs...) } // DescribeFastSnapshotRestoresRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresRequest), arg0) } // DescribeFastSnapshotRestoresPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFastSnapshotRestoresPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFastSnapshotRestoresPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFastSnapshotRestoresPages), arg0, arg1) } // DescribeFastSnapshotRestoresPagesWithContext mocks base method func (m *MockEC2API) DescribeFastSnapshotRestoresPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFastSnapshotRestoresPagesWithContext), varargs...) } // DescribeFleetHistory mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistory), arg0) } // DescribeFleetHistoryWithContext mocks base method func (m *MockEC2API) DescribeFleetHistoryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFleetHistoryWithContext), varargs...) } // DescribeFleetHistoryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryRequest), arg0) } // DescribeFleetInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstances), arg0) } // DescribeFleetInstancesWithContext mocks base method func (m *MockEC2API) DescribeFleetInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFleetInstancesWithContext), varargs...) } // DescribeFleetInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesRequest), arg0) } // DescribeFleets mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeFleets), arg0) } // DescribeFleetsWithContext mocks base method func (m *MockEC2API) DescribeFleetsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFleetsWithContext), varargs...) } // DescribeFleetsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsRequest), arg0) } // DescribeFleetsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPages), arg0, arg1) } // DescribeFleetsPagesWithContext mocks base method func (m *MockEC2API) DescribeFleetsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFleetsPagesWithContext), varargs...) } // DescribeFlowLogs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogs), arg0) } // DescribeFlowLogsWithContext mocks base method func (m *MockEC2API) DescribeFlowLogsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFlowLogsWithContext), varargs...) } // DescribeFlowLogsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsRequest), arg0) } // DescribeFlowLogsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPages), arg0, arg1) } // DescribeFlowLogsPagesWithContext mocks base method func (m *MockEC2API) DescribeFlowLogsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFlowLogsPagesWithContext), varargs...) } // DescribeFpgaImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttribute), arg0) } // DescribeFpgaImageAttributeWithContext mocks base method func (m *MockEC2API) DescribeFpgaImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFpgaImageAttributeWithContext), varargs...) } // DescribeFpgaImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeRequest), arg0) } // DescribeFpgaImages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImages), arg0) } // DescribeFpgaImagesWithContext mocks base method func (m *MockEC2API) DescribeFpgaImagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFpgaImagesWithContext), varargs...) } // DescribeFpgaImagesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesRequest), arg0) } // DescribeFpgaImagesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPages), arg0, arg1) } // DescribeFpgaImagesPagesWithContext mocks base method func (m *MockEC2API) DescribeFpgaImagesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeFpgaImagesPagesWithContext), varargs...) } // DescribeHostReservationOfferings mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferings), arg0) } // DescribeHostReservationOfferingsWithContext mocks base method func (m *MockEC2API) DescribeHostReservationOfferingsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostReservationOfferingsWithContext), varargs...) } // DescribeHostReservationOfferingsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsRequest), arg0) } // DescribeHostReservationOfferingsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPages), arg0, arg1) } // DescribeHostReservationOfferingsPagesWithContext mocks base method func (m *MockEC2API) DescribeHostReservationOfferingsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostReservationOfferingsPagesWithContext), varargs...) } // DescribeHostReservations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservations), arg0) } // DescribeHostReservationsWithContext mocks base method func (m *MockEC2API) DescribeHostReservationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostReservationsWithContext), varargs...) } // DescribeHostReservationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsRequest), arg0) } // DescribeHostReservationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPages), arg0, arg1) } // DescribeHostReservationsPagesWithContext mocks base method func (m *MockEC2API) DescribeHostReservationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostReservationsPagesWithContext), varargs...) } // DescribeHosts mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeHosts), arg0) } // DescribeHostsWithContext mocks base method func (m *MockEC2API) DescribeHostsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostsWithContext), varargs...) } // DescribeHostsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsRequest), arg0) } // DescribeHostsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPages), arg0, arg1) } // DescribeHostsPagesWithContext mocks base method func (m *MockEC2API) DescribeHostsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeHostsPagesWithContext), varargs...) } // DescribeIamInstanceProfileAssociations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociations), arg0) } // DescribeIamInstanceProfileAssociationsWithContext mocks base method func (m *MockEC2API) DescribeIamInstanceProfileAssociationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsWithContext), varargs...) } // DescribeIamInstanceProfileAssociationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0) } // DescribeIamInstanceProfileAssociationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1) } // DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPagesWithContext), varargs...) } // DescribeIdFormat mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormat), arg0) } // DescribeIdFormatWithContext mocks base method func (m *MockEC2API) DescribeIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIdFormatWithContext), varargs...) } // DescribeIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatRequest), arg0) } // DescribeIdentityIdFormat mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormat), arg0) } // DescribeIdentityIdFormatWithContext mocks base method func (m *MockEC2API) DescribeIdentityIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIdentityIdFormatWithContext), varargs...) } // DescribeIdentityIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatRequest), arg0) } // DescribeImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttribute), arg0) } // DescribeImageAttributeWithContext mocks base method func (m *MockEC2API) DescribeImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImageAttributeWithContext), varargs...) } // DescribeImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeRequest), arg0) } // DescribeImages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), arg0) } // DescribeImagesWithContext mocks base method func (m *MockEC2API) DescribeImagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImagesWithContext), varargs...) } // DescribeImagesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesRequest), arg0) } // DescribeImportImageTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasks), arg0) } // DescribeImportImageTasksWithContext mocks base method func (m *MockEC2API) DescribeImportImageTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImportImageTasksWithContext), varargs...) } // DescribeImportImageTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0) } // DescribeImportImageTasksPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPages), arg0, arg1) } // DescribeImportImageTasksPagesWithContext mocks base method func (m *MockEC2API) DescribeImportImageTasksPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImportImageTasksPagesWithContext), varargs...) } // DescribeImportSnapshotTasks mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasks), arg0) } // DescribeImportSnapshotTasksWithContext mocks base method func (m *MockEC2API) DescribeImportSnapshotTasksWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImportSnapshotTasksWithContext), varargs...) } // DescribeImportSnapshotTasksRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksRequest), arg0) } // DescribeImportSnapshotTasksPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPages), arg0, arg1) } // DescribeImportSnapshotTasksPagesWithContext mocks base method func (m *MockEC2API) DescribeImportSnapshotTasksPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeImportSnapshotTasksPagesWithContext), varargs...) } // DescribeInstanceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttribute), arg0) } // DescribeInstanceAttributeWithContext mocks base method func (m *MockEC2API) DescribeInstanceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceAttributeWithContext), varargs...) } // DescribeInstanceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeRequest), arg0) } // DescribeInstanceCreditSpecifications mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecifications), arg0) } // DescribeInstanceCreditSpecificationsWithContext mocks base method func (m *MockEC2API) DescribeInstanceCreditSpecificationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsWithContext), varargs...) } // DescribeInstanceCreditSpecificationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsRequest), arg0) } // DescribeInstanceCreditSpecificationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1) } // DescribeInstanceCreditSpecificationsPagesWithContext mocks base method func (m *MockEC2API) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPagesWithContext), varargs...) } // DescribeInstanceEventNotificationAttributes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributes), arg0) } // DescribeInstanceEventNotificationAttributesWithContext mocks base method func (m *MockEC2API) DescribeInstanceEventNotificationAttributesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesWithContext), varargs...) } // DescribeInstanceEventNotificationAttributesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceEventNotificationAttributesRequest), arg0) } // DescribeInstanceStatus mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatus), arg0) } // DescribeInstanceStatusWithContext mocks base method func (m *MockEC2API) DescribeInstanceStatusWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceStatusWithContext), varargs...) } // DescribeInstanceStatusRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusRequest), arg0) } // DescribeInstanceStatusPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPages), arg0, arg1) } // DescribeInstanceStatusPagesWithContext mocks base method func (m *MockEC2API) DescribeInstanceStatusPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceStatusPagesWithContext), varargs...) } // DescribeInstanceTypeOfferings mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypeOfferings(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferings), arg0) } // DescribeInstanceTypeOfferingsWithContext mocks base method func (m *MockEC2API) DescribeInstanceTypeOfferingsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceTypeOfferingsWithContext), varargs...) } // DescribeInstanceTypeOfferingsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsRequest), arg0) } // DescribeInstanceTypeOfferingsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypeOfferingsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypeOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPages), arg0, arg1) } // DescribeInstanceTypeOfferingsPagesWithContext mocks base method func (m *MockEC2API) DescribeInstanceTypeOfferingsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceTypeOfferingsPagesWithContext), varargs...) } // DescribeInstanceTypes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypes", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypes), arg0) } // DescribeInstanceTypesWithContext mocks base method func (m *MockEC2API) DescribeInstanceTypesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceTypesWithContext), varargs...) } // DescribeInstanceTypesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesRequest), arg0) } // DescribeInstanceTypesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstanceTypesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceTypesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceTypesPages), arg0, arg1) } // DescribeInstanceTypesPagesWithContext mocks base method func (m *MockEC2API) DescribeInstanceTypesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstanceTypesPagesWithContext), varargs...) } // DescribeInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), arg0) } // DescribeInstancesWithContext mocks base method func (m *MockEC2API) DescribeInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstancesWithContext), varargs...) } // DescribeInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesRequest), arg0) } // DescribeInstancesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPages), arg0, arg1) } // DescribeInstancesPagesWithContext mocks base method func (m *MockEC2API) DescribeInstancesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInstancesPagesWithContext), varargs...) } // DescribeInternetGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), arg0) } // DescribeInternetGatewaysWithContext mocks base method func (m *MockEC2API) DescribeInternetGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInternetGatewaysWithContext), varargs...) } // DescribeInternetGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysRequest), arg0) } // DescribeInternetGatewaysPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPages), arg0, arg1) } // DescribeInternetGatewaysPagesWithContext mocks base method func (m *MockEC2API) DescribeInternetGatewaysPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeInternetGatewaysPagesWithContext), varargs...) } // DescribeIpv6Pools mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIpv6Pools(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6Pools", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6Pools), arg0) } // DescribeIpv6PoolsWithContext mocks base method func (m *MockEC2API) DescribeIpv6PoolsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIpv6PoolsWithContext), varargs...) } // DescribeIpv6PoolsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIpv6PoolsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsRequest), arg0) } // DescribeIpv6PoolsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeIpv6PoolsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIpv6PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIpv6PoolsPages), arg0, arg1) } // DescribeIpv6PoolsPagesWithContext mocks base method func (m *MockEC2API) DescribeIpv6PoolsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeIpv6PoolsPagesWithContext), varargs...) } // DescribeKeyPairs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairs), arg0) } // DescribeKeyPairsWithContext mocks base method func (m *MockEC2API) DescribeKeyPairsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeKeyPairsWithContext), varargs...) } // DescribeKeyPairsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsRequest), arg0) } // DescribeLaunchTemplateVersions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), arg0) } // DescribeLaunchTemplateVersionsWithContext mocks base method func (m *MockEC2API) DescribeLaunchTemplateVersionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLaunchTemplateVersionsWithContext), varargs...) } // DescribeLaunchTemplateVersionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsRequest), arg0) } // DescribeLaunchTemplateVersionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1) } // DescribeLaunchTemplateVersionsPagesWithContext mocks base method func (m *MockEC2API) DescribeLaunchTemplateVersionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPagesWithContext), varargs...) } // DescribeLaunchTemplates mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplates), arg0) } // DescribeLaunchTemplatesWithContext mocks base method func (m *MockEC2API) DescribeLaunchTemplatesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLaunchTemplatesWithContext), varargs...) } // DescribeLaunchTemplatesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesRequest), arg0) } // DescribeLaunchTemplatesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPages), arg0, arg1) } // DescribeLaunchTemplatesPagesWithContext mocks base method func (m *MockEC2API) DescribeLaunchTemplatesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLaunchTemplatesPagesWithContext), varargs...) } // DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociations), arg0) } // DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsWithContext), varargs...) } // DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsRequest), arg0) } // DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPages), arg0, arg1) } // DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVirtualInterfaceGroupAssociationsPagesWithContext), varargs...) } // DescribeLocalGatewayRouteTableVpcAssociations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociations), arg0) } // DescribeLocalGatewayRouteTableVpcAssociationsWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsWithContext), varargs...) } // DescribeLocalGatewayRouteTableVpcAssociationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsRequest), arg0) } // DescribeLocalGatewayRouteTableVpcAssociationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTableVpcAssociationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTableVpcAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPages), arg0, arg1) } // DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTableVpcAssociationsPagesWithContext), varargs...) } // DescribeLocalGatewayRouteTables mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTables(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTables), arg0) } // DescribeLocalGatewayRouteTablesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTablesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesWithContext), varargs...) } // DescribeLocalGatewayRouteTablesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesRequest), arg0) } // DescribeLocalGatewayRouteTablesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPages), arg0, arg1) } // DescribeLocalGatewayRouteTablesPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayRouteTablesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayRouteTablesPagesWithContext), varargs...) } // DescribeLocalGatewayVirtualInterfaceGroups mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroups), arg0) } // DescribeLocalGatewayVirtualInterfaceGroupsWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsWithContext), varargs...) } // DescribeLocalGatewayVirtualInterfaceGroupsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsRequest), arg0) } // DescribeLocalGatewayVirtualInterfaceGroupsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaceGroupsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaceGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPages), arg0, arg1) } // DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaceGroupsPagesWithContext), varargs...) } // DescribeLocalGatewayVirtualInterfaces mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfaces(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfaces), arg0) } // DescribeLocalGatewayVirtualInterfacesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesWithContext), varargs...) } // DescribeLocalGatewayVirtualInterfacesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesRequest), arg0) } // DescribeLocalGatewayVirtualInterfacesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewayVirtualInterfacesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewayVirtualInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPages), arg0, arg1) } // DescribeLocalGatewayVirtualInterfacesPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewayVirtualInterfacesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewayVirtualInterfacesPagesWithContext), varargs...) } // DescribeLocalGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGateways), arg0) } // DescribeLocalGatewaysWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewaysWithContext), varargs...) } // DescribeLocalGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysRequest), arg0) } // DescribeLocalGatewaysPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeLocalGatewaysPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLocalGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLocalGatewaysPages), arg0, arg1) } // DescribeLocalGatewaysPagesWithContext mocks base method func (m *MockEC2API) DescribeLocalGatewaysPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeLocalGatewaysPagesWithContext), varargs...) } // DescribeMovingAddresses mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddresses), arg0) } // DescribeMovingAddressesWithContext mocks base method func (m *MockEC2API) DescribeMovingAddressesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeMovingAddressesWithContext), varargs...) } // DescribeMovingAddressesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesRequest), arg0) } // DescribeMovingAddressesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPages), arg0, arg1) } // DescribeMovingAddressesPagesWithContext mocks base method func (m *MockEC2API) DescribeMovingAddressesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeMovingAddressesPagesWithContext), varargs...) } // DescribeNatGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), arg0) } // DescribeNatGatewaysWithContext mocks base method func (m *MockEC2API) DescribeNatGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNatGatewaysWithContext), varargs...) } // DescribeNatGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysRequest), arg0) } // DescribeNatGatewaysPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPages), arg0, arg1) } // DescribeNatGatewaysPagesWithContext mocks base method func (m *MockEC2API) DescribeNatGatewaysPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNatGatewaysPagesWithContext), varargs...) } // DescribeNetworkAcls mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAcls), arg0) } // DescribeNetworkAclsWithContext mocks base method func (m *MockEC2API) DescribeNetworkAclsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkAclsWithContext), varargs...) } // DescribeNetworkAclsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsRequest), arg0) } // DescribeNetworkAclsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPages), arg0, arg1) } // DescribeNetworkAclsPagesWithContext mocks base method func (m *MockEC2API) DescribeNetworkAclsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkAclsPagesWithContext), varargs...) } // DescribeNetworkInterfaceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), arg0) } // DescribeNetworkInterfaceAttributeWithContext mocks base method func (m *MockEC2API) DescribeNetworkInterfaceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeWithContext), varargs...) } // DescribeNetworkInterfaceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeRequest), arg0) } // DescribeNetworkInterfacePermissions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissions), arg0) } // DescribeNetworkInterfacePermissionsWithContext mocks base method func (m *MockEC2API) DescribeNetworkInterfacePermissionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsWithContext), varargs...) } // DescribeNetworkInterfacePermissionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsRequest), arg0) } // DescribeNetworkInterfacePermissionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1) } // DescribeNetworkInterfacePermissionsPagesWithContext mocks base method func (m *MockEC2API) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPagesWithContext), varargs...) } // DescribeNetworkInterfaces mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), arg0) } // DescribeNetworkInterfacesWithContext mocks base method func (m *MockEC2API) DescribeNetworkInterfacesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkInterfacesWithContext), varargs...) } // DescribeNetworkInterfacesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesRequest), arg0) } // DescribeNetworkInterfacesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPages), arg0, arg1) } // DescribeNetworkInterfacesPagesWithContext mocks base method func (m *MockEC2API) DescribeNetworkInterfacesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeNetworkInterfacesPagesWithContext), varargs...) } // DescribePlacementGroups mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroups), arg0) } // DescribePlacementGroupsWithContext mocks base method func (m *MockEC2API) DescribePlacementGroupsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePlacementGroupsWithContext), varargs...) } // DescribePlacementGroupsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsRequest), arg0) } // DescribePrefixLists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixLists), arg0) } // DescribePrefixListsWithContext mocks base method func (m *MockEC2API) DescribePrefixListsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePrefixListsWithContext), varargs...) } // DescribePrefixListsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsRequest), arg0) } // DescribePrefixListsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPages), arg0, arg1) } // DescribePrefixListsPagesWithContext mocks base method func (m *MockEC2API) DescribePrefixListsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePrefixListsPagesWithContext), varargs...) } // DescribePrincipalIdFormat mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormat), arg0) } // DescribePrincipalIdFormatWithContext mocks base method func (m *MockEC2API) DescribePrincipalIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePrincipalIdFormatWithContext), varargs...) } // DescribePrincipalIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatRequest), arg0) } // DescribePrincipalIdFormatPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPages), arg0, arg1) } // DescribePrincipalIdFormatPagesWithContext mocks base method func (m *MockEC2API) DescribePrincipalIdFormatPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePrincipalIdFormatPagesWithContext), varargs...) } // DescribePublicIpv4Pools mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), arg0) } // DescribePublicIpv4PoolsWithContext mocks base method func (m *MockEC2API) DescribePublicIpv4PoolsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePublicIpv4PoolsWithContext), varargs...) } // DescribePublicIpv4PoolsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsRequest), arg0) } // DescribePublicIpv4PoolsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPages), arg0, arg1) } // DescribePublicIpv4PoolsPagesWithContext mocks base method func (m *MockEC2API) DescribePublicIpv4PoolsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribePublicIpv4PoolsPagesWithContext), varargs...) } // DescribeRegions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2API)(nil).DescribeRegions), arg0) } // DescribeRegionsWithContext mocks base method func (m *MockEC2API) DescribeRegionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...) } // DescribeRegionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsRequest), arg0) } // DescribeReservedInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstances), arg0) } // DescribeReservedInstancesWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesWithContext), varargs...) } // DescribeReservedInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesRequest), arg0) } // DescribeReservedInstancesListings mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListings), arg0) } // DescribeReservedInstancesListingsWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesListingsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesListingsWithContext), varargs...) } // DescribeReservedInstancesListingsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsRequest), arg0) } // DescribeReservedInstancesModifications mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModifications), arg0) } // DescribeReservedInstancesModificationsWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesModificationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesModificationsWithContext), varargs...) } // DescribeReservedInstancesModificationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsRequest), arg0) } // DescribeReservedInstancesModificationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1) } // DescribeReservedInstancesModificationsPagesWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesModificationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesModificationsPagesWithContext), varargs...) } // DescribeReservedInstancesOfferings mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferings), arg0) } // DescribeReservedInstancesOfferingsWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesOfferingsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesOfferingsWithContext), varargs...) } // DescribeReservedInstancesOfferingsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsRequest), arg0) } // DescribeReservedInstancesOfferingsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1) } // DescribeReservedInstancesOfferingsPagesWithContext mocks base method func (m *MockEC2API) DescribeReservedInstancesOfferingsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPagesWithContext), varargs...) } // DescribeRouteTables mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), arg0) } // DescribeRouteTablesWithContext mocks base method func (m *MockEC2API) DescribeRouteTablesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeRouteTablesWithContext), varargs...) } // DescribeRouteTablesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesRequest), arg0) } // DescribeRouteTablesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPages), arg0, arg1) } // DescribeRouteTablesPagesWithContext mocks base method func (m *MockEC2API) DescribeRouteTablesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeRouteTablesPagesWithContext), varargs...) } // DescribeScheduledInstanceAvailability mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailability), arg0) } // DescribeScheduledInstanceAvailabilityWithContext mocks base method func (m *MockEC2API) DescribeScheduledInstanceAvailabilityWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityWithContext), varargs...) } // DescribeScheduledInstanceAvailabilityRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0) } // DescribeScheduledInstanceAvailabilityPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1) } // DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPagesWithContext), varargs...) } // DescribeScheduledInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstances), arg0) } // DescribeScheduledInstancesWithContext mocks base method func (m *MockEC2API) DescribeScheduledInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeScheduledInstancesWithContext), varargs...) } // DescribeScheduledInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesRequest), arg0) } // DescribeScheduledInstancesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPages), arg0, arg1) } // DescribeScheduledInstancesPagesWithContext mocks base method func (m *MockEC2API) DescribeScheduledInstancesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeScheduledInstancesPagesWithContext), varargs...) } // DescribeSecurityGroupReferences mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferences), arg0) } // DescribeSecurityGroupReferencesWithContext mocks base method func (m *MockEC2API) DescribeSecurityGroupReferencesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSecurityGroupReferencesWithContext), varargs...) } // DescribeSecurityGroupReferencesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesRequest), arg0) } // DescribeSecurityGroups mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), arg0) } // DescribeSecurityGroupsWithContext mocks base method func (m *MockEC2API) DescribeSecurityGroupsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSecurityGroupsWithContext), varargs...) } // DescribeSecurityGroupsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsRequest), arg0) } // DescribeSecurityGroupsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPages), arg0, arg1) } // DescribeSecurityGroupsPagesWithContext mocks base method func (m *MockEC2API) DescribeSecurityGroupsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSecurityGroupsPagesWithContext), varargs...) } // DescribeSnapshotAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttribute), arg0) } // DescribeSnapshotAttributeWithContext mocks base method func (m *MockEC2API) DescribeSnapshotAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSnapshotAttributeWithContext), varargs...) } // DescribeSnapshotAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeRequest), arg0) } // DescribeSnapshots mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshots), arg0) } // DescribeSnapshotsWithContext mocks base method func (m *MockEC2API) DescribeSnapshotsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSnapshotsWithContext), varargs...) } // DescribeSnapshotsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsRequest), arg0) } // DescribeSnapshotsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPages), arg0, arg1) } // DescribeSnapshotsPagesWithContext mocks base method func (m *MockEC2API) DescribeSnapshotsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSnapshotsPagesWithContext), varargs...) } // DescribeSpotDatafeedSubscription mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscription), arg0) } // DescribeSpotDatafeedSubscriptionWithContext mocks base method func (m *MockEC2API) DescribeSpotDatafeedSubscriptionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionWithContext), varargs...) } // DescribeSpotDatafeedSubscriptionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0) } // DescribeSpotFleetInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstances), arg0) } // DescribeSpotFleetInstancesWithContext mocks base method func (m *MockEC2API) DescribeSpotFleetInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotFleetInstancesWithContext), varargs...) } // DescribeSpotFleetInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesRequest), arg0) } // DescribeSpotFleetRequestHistory mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistory), arg0) } // DescribeSpotFleetRequestHistoryWithContext mocks base method func (m *MockEC2API) DescribeSpotFleetRequestHistoryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryWithContext), varargs...) } // DescribeSpotFleetRequestHistoryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryRequest), arg0) } // DescribeSpotFleetRequests mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequests), arg0) } // DescribeSpotFleetRequestsWithContext mocks base method func (m *MockEC2API) DescribeSpotFleetRequestsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotFleetRequestsWithContext), varargs...) } // DescribeSpotFleetRequestsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsRequest), arg0) } // DescribeSpotFleetRequestsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPages), arg0, arg1) } // DescribeSpotFleetRequestsPagesWithContext mocks base method func (m *MockEC2API) DescribeSpotFleetRequestsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotFleetRequestsPagesWithContext), varargs...) } // DescribeSpotInstanceRequests mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequests), arg0) } // DescribeSpotInstanceRequestsWithContext mocks base method func (m *MockEC2API) DescribeSpotInstanceRequestsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotInstanceRequestsWithContext), varargs...) } // DescribeSpotInstanceRequestsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsRequest), arg0) } // DescribeSpotInstanceRequestsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1) } // DescribeSpotInstanceRequestsPagesWithContext mocks base method func (m *MockEC2API) DescribeSpotInstanceRequestsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotInstanceRequestsPagesWithContext), varargs...) } // DescribeSpotPriceHistory mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistory), arg0) } // DescribeSpotPriceHistoryWithContext mocks base method func (m *MockEC2API) DescribeSpotPriceHistoryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotPriceHistoryWithContext), varargs...) } // DescribeSpotPriceHistoryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryRequest), arg0) } // DescribeSpotPriceHistoryPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPages), arg0, arg1) } // DescribeSpotPriceHistoryPagesWithContext mocks base method func (m *MockEC2API) DescribeSpotPriceHistoryPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeSpotPriceHistoryPagesWithContext), varargs...) } // DescribeStaleSecurityGroups mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroups), arg0) } // DescribeStaleSecurityGroupsWithContext mocks base method func (m *MockEC2API) DescribeStaleSecurityGroupsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeStaleSecurityGroupsWithContext), varargs...) } // DescribeStaleSecurityGroupsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsRequest), arg0) } // DescribeStaleSecurityGroupsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1) } // DescribeStaleSecurityGroupsPagesWithContext mocks base method func (m *MockEC2API) DescribeStaleSecurityGroupsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeStaleSecurityGroupsPagesWithContext), varargs...) } // DescribeSubnets mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0) } // DescribeSubnetsWithContext mocks base method func (m *MockEC2API) DescribeSubnetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...) ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...) } // DescribeSubnetsRequest mocks base method func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput) return ret0, ret1 } // DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0) } // DescribeSubnetsPages mocks base method func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1) } // DescribeSubnetsPagesWithContext mocks base method func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, bool) bool, arg3 ...request.Option) error { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1, arg2} for _, a := range arg3 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DescribeSubnetsPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...) } // DescribeTags mocks base method func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeTags", arg0) ret0, _ := ret[0].(*ec2.DescribeTagsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeTags indicates an expected call of DescribeTags func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0) } // DescribeTagsWithContext mocks base method func (m *MockEC2API) DescribeTagsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTagsWithContext), varargs...) } // DescribeTagsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0) } // DescribeTagsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1) } // DescribeTagsPagesWithContext mocks base method func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTagsPagesWithContext), varargs...) } // DescribeTrafficMirrorFilters mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilters), arg0) } // DescribeTrafficMirrorFiltersWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorFiltersWithContext), varargs...) } // DescribeTrafficMirrorFiltersRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersRequest), arg0) } // DescribeTrafficMirrorFiltersPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1) } // DescribeTrafficMirrorFiltersPagesWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorFiltersPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPagesWithContext), varargs...) } // DescribeTrafficMirrorSessions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessions), arg0) } // DescribeTrafficMirrorSessionsWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorSessionsWithContext), varargs...) } // DescribeTrafficMirrorSessionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsRequest), arg0) } // DescribeTrafficMirrorSessionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1) } // DescribeTrafficMirrorSessionsPagesWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorSessionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPagesWithContext), varargs...) } // DescribeTrafficMirrorTargets mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargets), arg0) } // DescribeTrafficMirrorTargetsWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...) } // DescribeTrafficMirrorTargetsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0) } // DescribeTrafficMirrorTargetsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1) } // DescribeTrafficMirrorTargetsPagesWithContext mocks base method func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...) } // DescribeTransitGatewayAttachments mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachments), arg0) } // DescribeTransitGatewayAttachmentsWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayAttachmentsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...) } // DescribeTransitGatewayAttachmentsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsRequest), arg0) } // DescribeTransitGatewayAttachmentsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1) } // DescribeTransitGatewayAttachmentsPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPagesWithContext), varargs...) } // DescribeTransitGatewayMulticastDomains mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomains(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomains", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomains), arg0) } // DescribeTransitGatewayMulticastDomainsWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsWithContext), varargs...) } // DescribeTransitGatewayMulticastDomainsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsRequest), arg0) } // DescribeTransitGatewayMulticastDomainsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayMulticastDomainsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayMulticastDomainsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPages), arg0, arg1) } // DescribeTransitGatewayMulticastDomainsPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayMulticastDomainsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayMulticastDomainsPagesWithContext), varargs...) } // DescribeTransitGatewayPeeringAttachments mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachments(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachments), arg0) } // DescribeTransitGatewayPeeringAttachmentsWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsWithContext), varargs...) } // DescribeTransitGatewayPeeringAttachmentsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsRequest), arg0) } // DescribeTransitGatewayPeeringAttachmentsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayPeeringAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayPeeringAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPages), arg0, arg1) } // DescribeTransitGatewayPeeringAttachmentsPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayPeeringAttachmentsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayPeeringAttachmentsPagesWithContext), varargs...) } // DescribeTransitGatewayRouteTables mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTables), arg0) } // DescribeTransitGatewayRouteTablesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayRouteTablesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesWithContext), varargs...) } // DescribeTransitGatewayRouteTablesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesRequest), arg0) } // DescribeTransitGatewayRouteTablesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1) } // DescribeTransitGatewayRouteTablesPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPagesWithContext), varargs...) } // DescribeTransitGatewayVpcAttachments mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachments), arg0) } // DescribeTransitGatewayVpcAttachmentsWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsWithContext), varargs...) } // DescribeTransitGatewayVpcAttachmentsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0) } // DescribeTransitGatewayVpcAttachmentsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1) } // DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPagesWithContext), varargs...) } // DescribeTransitGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGateways), arg0) } // DescribeTransitGatewaysWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewaysWithContext), varargs...) } // DescribeTransitGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysRequest), arg0) } // DescribeTransitGatewaysPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPages), arg0, arg1) } // DescribeTransitGatewaysPagesWithContext mocks base method func (m *MockEC2API) DescribeTransitGatewaysPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeTransitGatewaysPagesWithContext), varargs...) } // DescribeVolumeAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttribute), arg0) } // DescribeVolumeAttributeWithContext mocks base method func (m *MockEC2API) DescribeVolumeAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumeAttributeWithContext), varargs...) } // DescribeVolumeAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeRequest), arg0) } // DescribeVolumeStatus mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatus), arg0) } // DescribeVolumeStatusWithContext mocks base method func (m *MockEC2API) DescribeVolumeStatusWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumeStatusWithContext), varargs...) } // DescribeVolumeStatusRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusRequest), arg0) } // DescribeVolumeStatusPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPages), arg0, arg1) } // DescribeVolumeStatusPagesWithContext mocks base method func (m *MockEC2API) DescribeVolumeStatusPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumeStatusPagesWithContext), varargs...) } // DescribeVolumes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumes), arg0) } // DescribeVolumesWithContext mocks base method func (m *MockEC2API) DescribeVolumesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumesWithContext), varargs...) } // DescribeVolumesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesRequest), arg0) } // DescribeVolumesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPages), arg0, arg1) } // DescribeVolumesPagesWithContext mocks base method func (m *MockEC2API) DescribeVolumesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumesPagesWithContext), varargs...) } // DescribeVolumesModifications mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModifications), arg0) } // DescribeVolumesModificationsWithContext mocks base method func (m *MockEC2API) DescribeVolumesModificationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumesModificationsWithContext), varargs...) } // DescribeVolumesModificationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsRequest), arg0) } // DescribeVolumesModificationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPages), arg0, arg1) } // DescribeVolumesModificationsPagesWithContext mocks base method func (m *MockEC2API) DescribeVolumesModificationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVolumesModificationsPagesWithContext), varargs...) } // DescribeVpcAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), arg0) } // DescribeVpcAttributeWithContext mocks base method func (m *MockEC2API) DescribeVpcAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcAttributeWithContext), varargs...) } // DescribeVpcAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeRequest), arg0) } // DescribeVpcClassicLink mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLink), arg0) } // DescribeVpcClassicLinkWithContext mocks base method func (m *MockEC2API) DescribeVpcClassicLinkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcClassicLinkWithContext), varargs...) } // DescribeVpcClassicLinkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkRequest), arg0) } // DescribeVpcClassicLinkDnsSupport mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupport), arg0) } // DescribeVpcClassicLinkDnsSupportWithContext mocks base method func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportWithContext), varargs...) } // DescribeVpcClassicLinkDnsSupportRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0) } // DescribeVpcClassicLinkDnsSupportPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1) } // DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPagesWithContext), varargs...) } // DescribeVpcEndpointConnectionNotifications mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotifications), arg0) } // DescribeVpcEndpointConnectionNotificationsWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsWithContext), varargs...) } // DescribeVpcEndpointConnectionNotificationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0) } // DescribeVpcEndpointConnectionNotificationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1) } // DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPagesWithContext), varargs...) } // DescribeVpcEndpointConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnections), arg0) } // DescribeVpcEndpointConnectionsWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointConnectionsWithContext), varargs...) } // DescribeVpcEndpointConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsRequest), arg0) } // DescribeVpcEndpointConnectionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1) } // DescribeVpcEndpointConnectionsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointConnectionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPagesWithContext), varargs...) } // DescribeVpcEndpointServiceConfigurations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurations), arg0) } // DescribeVpcEndpointServiceConfigurationsWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsWithContext), varargs...) } // DescribeVpcEndpointServiceConfigurationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0) } // DescribeVpcEndpointServiceConfigurationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1) } // DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPagesWithContext), varargs...) } // DescribeVpcEndpointServicePermissions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissions), arg0) } // DescribeVpcEndpointServicePermissionsWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointServicePermissionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsWithContext), varargs...) } // DescribeVpcEndpointServicePermissionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0) } // DescribeVpcEndpointServicePermissionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1) } // DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPagesWithContext), varargs...) } // DescribeVpcEndpointServices mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServices), arg0) } // DescribeVpcEndpointServicesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointServicesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointServicesWithContext), varargs...) } // DescribeVpcEndpointServicesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesRequest), arg0) } // DescribeVpcEndpoints mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), arg0) } // DescribeVpcEndpointsWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), varargs...) } // DescribeVpcEndpointsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0) } // DescribeVpcEndpointsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPages), arg0, arg1) } // DescribeVpcEndpointsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcEndpointsPagesWithContext), varargs...) } // DescribeVpcPeeringConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnections), arg0) } // DescribeVpcPeeringConnectionsWithContext mocks base method func (m *MockEC2API) DescribeVpcPeeringConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...) } // DescribeVpcPeeringConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsRequest), arg0) } // DescribeVpcPeeringConnectionsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1) } // DescribeVpcPeeringConnectionsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcPeeringConnectionsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPagesWithContext), varargs...) } // DescribeVpcs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), arg0) } // DescribeVpcsWithContext mocks base method func (m *MockEC2API) DescribeVpcsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcsWithContext), varargs...) } // DescribeVpcsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsRequest), arg0) } // DescribeVpcsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPages), arg0, arg1) } // DescribeVpcsPagesWithContext mocks base method func (m *MockEC2API) DescribeVpcsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpcsPagesWithContext), varargs...) } // DescribeVpnConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnections), arg0) } // DescribeVpnConnectionsWithContext mocks base method func (m *MockEC2API) DescribeVpnConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpnConnectionsWithContext), varargs...) } // DescribeVpnConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsRequest), arg0) } // DescribeVpnGateways mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGateways), arg0) } // DescribeVpnGatewaysWithContext mocks base method func (m *MockEC2API) DescribeVpnGatewaysWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DescribeVpnGatewaysWithContext), varargs...) } // DescribeVpnGatewaysRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysRequest), arg0) } // DetachClassicLinkVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpc), arg0) } // DetachClassicLinkVpcWithContext mocks base method func (m *MockEC2API) DetachClassicLinkVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DetachClassicLinkVpcWithContext), varargs...) } // DetachClassicLinkVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcRequest), arg0) } // DetachInternetGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), arg0) } // DetachInternetGatewayWithContext mocks base method func (m *MockEC2API) DetachInternetGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DetachInternetGatewayWithContext), varargs...) } // DetachInternetGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayRequest), arg0) } // DetachNetworkInterface mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterface), arg0) } // DetachNetworkInterfaceWithContext mocks base method func (m *MockEC2API) DetachNetworkInterfaceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DetachNetworkInterfaceWithContext), varargs...) } // DetachNetworkInterfaceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceRequest), arg0) } // DetachVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2API)(nil).DetachVolume), arg0) } // DetachVolumeWithContext mocks base method func (m *MockEC2API) DetachVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DetachVolumeWithContext), varargs...) } // DetachVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeRequest), arg0) } // DetachVpnGateway mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGateway), arg0) } // DetachVpnGatewayWithContext mocks base method func (m *MockEC2API) DetachVpnGatewayWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DetachVpnGatewayWithContext), varargs...) } // DetachVpnGatewayRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayRequest), arg0) } // DisableEbsEncryptionByDefault mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefault), arg0) } // DisableEbsEncryptionByDefaultWithContext mocks base method func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableEbsEncryptionByDefaultWithContext), varargs...) } // DisableEbsEncryptionByDefaultRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultRequest), arg0) } // DisableFastSnapshotRestores mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableFastSnapshotRestores(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestores), arg0) } // DisableFastSnapshotRestoresWithContext mocks base method func (m *MockEC2API) DisableFastSnapshotRestoresWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableFastSnapshotRestoresWithContext), varargs...) } // DisableFastSnapshotRestoresRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).DisableFastSnapshotRestoresRequest), arg0) } // DisableTransitGatewayRouteTablePropagation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagation), arg0) } // DisableTransitGatewayRouteTablePropagationWithContext mocks base method func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationWithContext), varargs...) } // DisableTransitGatewayRouteTablePropagationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0) } // DisableVgwRoutePropagation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagation), arg0) } // DisableVgwRoutePropagationWithContext mocks base method func (m *MockEC2API) DisableVgwRoutePropagationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableVgwRoutePropagationWithContext), varargs...) } // DisableVgwRoutePropagationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationRequest), arg0) } // DisableVpcClassicLink mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLink), arg0) } // DisableVpcClassicLinkWithContext mocks base method func (m *MockEC2API) DisableVpcClassicLinkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableVpcClassicLinkWithContext), varargs...) } // DisableVpcClassicLinkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkRequest), arg0) } // DisableVpcClassicLinkDnsSupport mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupport), arg0) } // DisableVpcClassicLinkDnsSupportWithContext mocks base method func (m *MockEC2API) DisableVpcClassicLinkDnsSupportWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportWithContext), varargs...) } // DisableVpcClassicLinkDnsSupportRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0) } // DisassociateAddress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), arg0) } // DisassociateAddressWithContext mocks base method func (m *MockEC2API) DisassociateAddressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateAddressWithContext), varargs...) } // DisassociateAddressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressRequest), arg0) } // DisassociateClientVpnTargetNetwork mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetwork), arg0) } // DisassociateClientVpnTargetNetworkWithContext mocks base method func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...) } // DisassociateClientVpnTargetNetworkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkRequest), arg0) } // DisassociateIamInstanceProfile mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfile), arg0) } // DisassociateIamInstanceProfileWithContext mocks base method func (m *MockEC2API) DisassociateIamInstanceProfileWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateIamInstanceProfileWithContext), varargs...) } // DisassociateIamInstanceProfileRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileRequest), arg0) } // DisassociateRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), arg0) } // DisassociateRouteTableWithContext mocks base method func (m *MockEC2API) DisassociateRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateRouteTableWithContext), varargs...) } // DisassociateRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableRequest), arg0) } // DisassociateSubnetCidrBlock mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlock), arg0) } // DisassociateSubnetCidrBlockWithContext mocks base method func (m *MockEC2API) DisassociateSubnetCidrBlockWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateSubnetCidrBlockWithContext), varargs...) } // DisassociateSubnetCidrBlockRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockRequest), arg0) } // DisassociateTransitGatewayMulticastDomain mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomain(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomain", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomain), arg0) } // DisassociateTransitGatewayMulticastDomainWithContext mocks base method func (m *MockEC2API) DisassociateTransitGatewayMulticastDomainWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainWithContext), varargs...) } // DisassociateTransitGatewayMulticastDomainRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateTransitGatewayMulticastDomainRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayMulticastDomainRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayMulticastDomainRequest), arg0) } // DisassociateTransitGatewayRouteTable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTable), arg0) } // DisassociateTransitGatewayRouteTableWithContext mocks base method func (m *MockEC2API) DisassociateTransitGatewayRouteTableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...) } // DisassociateTransitGatewayRouteTableRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableRequest), arg0) } // DisassociateVpcCidrBlock mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), arg0) } // DisassociateVpcCidrBlockWithContext mocks base method func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 aws.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 *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...) } // DisassociateVpcCidrBlockRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockRequest), arg0) } // EnableEbsEncryptionByDefault mocks base method func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0) ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0) } // EnableEbsEncryptionByDefaultWithContext mocks base method func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...) ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) } // EnableEbsEncryptionByDefaultRequest mocks base method func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput) return ret0, ret1 } // EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0) } // EnableFastSnapshotRestores mocks base method func (m *MockEC2API) EnableFastSnapshotRestores(arg0 *ec2.EnableFastSnapshotRestoresInput) (*ec2.EnableFastSnapshotRestoresOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableFastSnapshotRestores", arg0) ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // EnableFastSnapshotRestores indicates an expected call of EnableFastSnapshotRestores func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestores(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestores", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestores), arg0) } // EnableFastSnapshotRestoresWithContext mocks base method func (m *MockEC2API) EnableFastSnapshotRestoresWithContext(arg0 aws.Context, arg1 *ec2.EnableFastSnapshotRestoresInput, arg2 ...request.Option) (*ec2.EnableFastSnapshotRestoresOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresWithContext", varargs...) ret0, _ := ret[0].(*ec2.EnableFastSnapshotRestoresOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // EnableFastSnapshotRestoresWithContext indicates an expected call of EnableFastSnapshotRestoresWithContext func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresWithContext), varargs...) } // EnableFastSnapshotRestoresRequest mocks base method func (m *MockEC2API) EnableFastSnapshotRestoresRequest(arg0 *ec2.EnableFastSnapshotRestoresInput) (*request.Request, *ec2.EnableFastSnapshotRestoresOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "EnableFastSnapshotRestoresRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*ec2.EnableFastSnapshotRestoresOutput) return ret0, ret1 } // EnableFastSnapshotRestoresRequest indicates an expected call of EnableFastSnapshotRestoresRequest func (mr *MockEC2APIMockRecorder) EnableFastSnapshotRestoresRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFastSnapshotRestoresRequest", reflect.TypeOf((*MockEC2API)(nil).EnableFastSnapshotRestoresRequest), arg0) } // EnableTransitGatewayRouteTablePropagation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagation), arg0) } // EnableTransitGatewayRouteTablePropagationWithContext mocks base method func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationWithContext), varargs...) } // EnableTransitGatewayRouteTablePropagationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0) } // EnableVgwRoutePropagation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagation), arg0) } // EnableVgwRoutePropagationWithContext mocks base method func (m *MockEC2API) EnableVgwRoutePropagationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).EnableVgwRoutePropagationWithContext), varargs...) } // EnableVgwRoutePropagationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationRequest), arg0) } // EnableVolumeIO mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIO), arg0) } // EnableVolumeIOWithContext mocks base method func (m *MockEC2API) EnableVolumeIOWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).EnableVolumeIOWithContext), varargs...) } // EnableVolumeIORequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIORequest), arg0) } // EnableVpcClassicLink mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLink), arg0) } // EnableVpcClassicLinkWithContext mocks base method func (m *MockEC2API) EnableVpcClassicLinkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).EnableVpcClassicLinkWithContext), varargs...) } // EnableVpcClassicLinkRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkRequest), arg0) } // EnableVpcClassicLinkDnsSupport mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupport), arg0) } // EnableVpcClassicLinkDnsSupportWithContext mocks base method func (m *MockEC2API) EnableVpcClassicLinkDnsSupportWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportWithContext), varargs...) } // EnableVpcClassicLinkDnsSupportRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0) } // ExportClientVpnClientCertificateRevocationList mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationList), arg0) } // ExportClientVpnClientCertificateRevocationListWithContext mocks base method func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListWithContext), varargs...) } // ExportClientVpnClientCertificateRevocationListRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0) } // ExportClientVpnClientConfiguration mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfiguration), arg0) } // ExportClientVpnClientConfigurationWithContext mocks base method func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ExportClientVpnClientConfigurationWithContext), varargs...) } // ExportClientVpnClientConfigurationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationRequest), arg0) } // ExportImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2API)(nil).ExportImage), arg0) } // ExportImageWithContext mocks base method func (m *MockEC2API) ExportImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ExportImageWithContext), varargs...) } // ExportImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ExportImageRequest), arg0) } // ExportTransitGatewayRoutes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0) } // ExportTransitGatewayRoutesWithContext mocks base method func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...) } // ExportTransitGatewayRoutesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0) } // GetAssociatedIpv6PoolCidrs mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrs", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrs), arg0) } // GetAssociatedIpv6PoolCidrsWithContext mocks base method func (m *MockEC2API) GetAssociatedIpv6PoolCidrsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsWithContext), varargs...) } // GetAssociatedIpv6PoolCidrsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsRequest), arg0) } // GetAssociatedIpv6PoolCidrsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetAssociatedIpv6PoolCidrsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAssociatedIpv6PoolCidrsPages", reflect.TypeOf((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPages), arg0, arg1) } // GetAssociatedIpv6PoolCidrsPagesWithContext mocks base method func (m *MockEC2API) GetAssociatedIpv6PoolCidrsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetAssociatedIpv6PoolCidrsPagesWithContext), varargs...) } // GetCapacityReservationUsage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0) } // GetCapacityReservationUsageWithContext mocks base method func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetCapacityReservationUsageWithContext), varargs...) } // GetCapacityReservationUsageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0) } // GetCoipPoolUsage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetCoipPoolUsage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsage", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsage), arg0) } // GetCoipPoolUsageWithContext mocks base method func (m *MockEC2API) GetCoipPoolUsageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetCoipPoolUsageWithContext), varargs...) } // GetCoipPoolUsageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetCoipPoolUsageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCoipPoolUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCoipPoolUsageRequest), arg0) } // GetConsoleOutput mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutput), arg0) } // GetConsoleOutputWithContext mocks base method func (m *MockEC2API) GetConsoleOutputWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetConsoleOutputWithContext), varargs...) } // GetConsoleOutputRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputRequest), arg0) } // GetConsoleScreenshot mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshot), arg0) } // GetConsoleScreenshotWithContext mocks base method func (m *MockEC2API) GetConsoleScreenshotWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetConsoleScreenshotWithContext), varargs...) } // GetConsoleScreenshotRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotRequest), arg0) } // GetDefaultCreditSpecification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetDefaultCreditSpecification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecification), arg0) } // GetDefaultCreditSpecificationWithContext mocks base method func (m *MockEC2API) GetDefaultCreditSpecificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetDefaultCreditSpecificationWithContext), varargs...) } // GetDefaultCreditSpecificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).GetDefaultCreditSpecificationRequest), arg0) } // GetEbsDefaultKmsKeyId mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyId), arg0) } // GetEbsDefaultKmsKeyIdWithContext mocks base method func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdWithContext), varargs...) } // GetEbsDefaultKmsKeyIdRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdRequest), arg0) } // GetEbsEncryptionByDefault mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefault), arg0) } // GetEbsEncryptionByDefaultWithContext mocks base method func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...) } // GetEbsEncryptionByDefaultRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultRequest), arg0) } // GetHostReservationPurchasePreview mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreview), arg0) } // GetHostReservationPurchasePreviewWithContext mocks base method func (m *MockEC2API) GetHostReservationPurchasePreviewWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetHostReservationPurchasePreviewWithContext), varargs...) } // GetHostReservationPurchasePreviewRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewRequest), arg0) } // GetLaunchTemplateData mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateData), arg0) } // GetLaunchTemplateDataWithContext mocks base method func (m *MockEC2API) GetLaunchTemplateDataWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetLaunchTemplateDataWithContext), varargs...) } // GetLaunchTemplateDataRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataRequest), arg0) } // GetPasswordData mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2API)(nil).GetPasswordData), arg0) } // GetPasswordDataWithContext mocks base method func (m *MockEC2API) GetPasswordDataWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetPasswordDataWithContext), varargs...) } // GetPasswordDataRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataRequest), arg0) } // GetReservedInstancesExchangeQuote mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuote), arg0) } // GetReservedInstancesExchangeQuoteWithContext mocks base method func (m *MockEC2API) GetReservedInstancesExchangeQuoteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...) } // GetReservedInstancesExchangeQuoteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteRequest), arg0) } // GetTransitGatewayAttachmentPropagations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagations), arg0) } // GetTransitGatewayAttachmentPropagationsWithContext mocks base method func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsWithContext), varargs...) } // GetTransitGatewayAttachmentPropagationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0) } // GetTransitGatewayAttachmentPropagationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1) } // GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPagesWithContext), varargs...) } // GetTransitGatewayMulticastDomainAssociations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociations), arg0) } // GetTransitGatewayMulticastDomainAssociationsWithContext mocks base method func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsWithContext), varargs...) } // GetTransitGatewayMulticastDomainAssociationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsRequest), arg0) } // GetTransitGatewayMulticastDomainAssociationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayMulticastDomainAssociationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayMulticastDomainAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPages), arg0, arg1) } // GetTransitGatewayMulticastDomainAssociationsPagesWithContext mocks base method func (m *MockEC2API) GetTransitGatewayMulticastDomainAssociationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayMulticastDomainAssociationsPagesWithContext), varargs...) } // GetTransitGatewayRouteTableAssociations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociations), arg0) } // GetTransitGatewayRouteTableAssociationsWithContext mocks base method func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsWithContext), varargs...) } // GetTransitGatewayRouteTableAssociationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0) } // GetTransitGatewayRouteTableAssociationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1) } // GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPagesWithContext), varargs...) } // GetTransitGatewayRouteTablePropagations mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagations), arg0) } // GetTransitGatewayRouteTablePropagationsWithContext mocks base method func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsWithContext), varargs...) } // GetTransitGatewayRouteTablePropagationsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0) } // GetTransitGatewayRouteTablePropagationsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1) } // GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPagesWithContext), varargs...) } // ImportClientVpnClientCertificateRevocationList mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationList), arg0) } // ImportClientVpnClientCertificateRevocationListWithContext mocks base method func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListWithContext), varargs...) } // ImportClientVpnClientCertificateRevocationListRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0) } // ImportImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2API)(nil).ImportImage), arg0) } // ImportImageWithContext mocks base method func (m *MockEC2API) ImportImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportImageWithContext), varargs...) } // ImportImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ImportImageRequest), arg0) } // ImportInstance mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2API)(nil).ImportInstance), arg0) } // ImportInstanceWithContext mocks base method func (m *MockEC2API) ImportInstanceWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportInstanceWithContext), varargs...) } // ImportInstanceRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceRequest), arg0) } // ImportKeyPair mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPair), arg0) } // ImportKeyPairWithContext mocks base method func (m *MockEC2API) ImportKeyPairWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportKeyPairWithContext), varargs...) } // ImportKeyPairRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairRequest), arg0) } // ImportSnapshot mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshot), arg0) } // ImportSnapshotWithContext mocks base method func (m *MockEC2API) ImportSnapshotWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportSnapshotWithContext), varargs...) } // ImportSnapshotRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotRequest), arg0) } // ImportVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2API)(nil).ImportVolume), arg0) } // ImportVolumeWithContext mocks base method func (m *MockEC2API) ImportVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ImportVolumeWithContext), varargs...) } // ImportVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0) } // ModifyAvailabilityZoneGroup mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroup", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroup), arg0) } // ModifyAvailabilityZoneGroupWithContext mocks base method func (m *MockEC2API) ModifyAvailabilityZoneGroupWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyAvailabilityZoneGroupWithContext), varargs...) } // ModifyAvailabilityZoneGroupRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyAvailabilityZoneGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyAvailabilityZoneGroupRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyAvailabilityZoneGroupRequest), arg0) } // ModifyCapacityReservation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0) } // ModifyCapacityReservationWithContext mocks base method func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyCapacityReservationWithContext), varargs...) } // ModifyCapacityReservationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0) } // ModifyClientVpnEndpoint mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpoint), arg0) } // ModifyClientVpnEndpointWithContext mocks base method func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyClientVpnEndpointWithContext), varargs...) } // ModifyClientVpnEndpointRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0) } // ModifyDefaultCreditSpecification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyDefaultCreditSpecification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecification), arg0) } // ModifyDefaultCreditSpecificationWithContext mocks base method func (m *MockEC2API) ModifyDefaultCreditSpecificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyDefaultCreditSpecificationWithContext), varargs...) } // ModifyDefaultCreditSpecificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyDefaultCreditSpecificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyDefaultCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyDefaultCreditSpecificationRequest), arg0) } // ModifyEbsDefaultKmsKeyId mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0) } // ModifyEbsDefaultKmsKeyIdWithContext mocks base method func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...) } // ModifyEbsDefaultKmsKeyIdRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0) } // ModifyFleet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyFleet), arg0) } // ModifyFleetWithContext mocks base method func (m *MockEC2API) ModifyFleetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyFleetWithContext), varargs...) } // ModifyFleetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetRequest), arg0) } // ModifyFpgaImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttribute), arg0) } // ModifyFpgaImageAttributeWithContext mocks base method func (m *MockEC2API) ModifyFpgaImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyFpgaImageAttributeWithContext), varargs...) } // ModifyFpgaImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeRequest), arg0) } // ModifyHosts mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2API)(nil).ModifyHosts), arg0) } // ModifyHostsWithContext mocks base method func (m *MockEC2API) ModifyHostsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyHostsWithContext), varargs...) } // ModifyHostsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsRequest), arg0) } // ModifyIdFormat mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormat), arg0) } // ModifyIdFormatWithContext mocks base method func (m *MockEC2API) ModifyIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyIdFormatWithContext), varargs...) } // ModifyIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatRequest), arg0) } // ModifyIdentityIdFormat mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormat), arg0) } // ModifyIdentityIdFormatWithContext mocks base method func (m *MockEC2API) ModifyIdentityIdFormatWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyIdentityIdFormatWithContext), varargs...) } // ModifyIdentityIdFormatRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatRequest), arg0) } // ModifyImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttribute), arg0) } // ModifyImageAttributeWithContext mocks base method func (m *MockEC2API) ModifyImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyImageAttributeWithContext), varargs...) } // ModifyImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeRequest), arg0) } // ModifyInstanceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttribute), arg0) } // ModifyInstanceAttributeWithContext mocks base method func (m *MockEC2API) ModifyInstanceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstanceAttributeWithContext), varargs...) } // ModifyInstanceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeRequest), arg0) } // ModifyInstanceCapacityReservationAttributes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributes), arg0) } // ModifyInstanceCapacityReservationAttributesWithContext mocks base method func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesWithContext), varargs...) } // ModifyInstanceCapacityReservationAttributesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0) } // ModifyInstanceCreditSpecification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecification), arg0) } // ModifyInstanceCreditSpecificationWithContext mocks base method func (m *MockEC2API) ModifyInstanceCreditSpecificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstanceCreditSpecificationWithContext), varargs...) } // ModifyInstanceCreditSpecificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationRequest), arg0) } // ModifyInstanceEventStartTime mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTime), arg0) } // ModifyInstanceEventStartTimeWithContext mocks base method func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstanceEventStartTimeWithContext), varargs...) } // ModifyInstanceEventStartTimeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeRequest), arg0) } // ModifyInstanceMetadataOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceMetadataOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptions), arg0) } // ModifyInstanceMetadataOptionsWithContext mocks base method func (m *MockEC2API) ModifyInstanceMetadataOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstanceMetadataOptionsWithContext), varargs...) } // ModifyInstanceMetadataOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstanceMetadataOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceMetadataOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceMetadataOptionsRequest), arg0) } // ModifyInstancePlacement mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacement), arg0) } // ModifyInstancePlacementWithContext mocks base method func (m *MockEC2API) ModifyInstancePlacementWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyInstancePlacementWithContext), varargs...) } // ModifyInstancePlacementRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementRequest), arg0) } // ModifyLaunchTemplate mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplate), arg0) } // ModifyLaunchTemplateWithContext mocks base method func (m *MockEC2API) ModifyLaunchTemplateWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyLaunchTemplateWithContext), varargs...) } // ModifyLaunchTemplateRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateRequest), arg0) } // ModifyNetworkInterfaceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), arg0) } // ModifyNetworkInterfaceAttributeWithContext mocks base method func (m *MockEC2API) ModifyNetworkInterfaceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeWithContext), varargs...) } // ModifyNetworkInterfaceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeRequest), arg0) } // ModifyReservedInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstances), arg0) } // ModifyReservedInstancesWithContext mocks base method func (m *MockEC2API) ModifyReservedInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyReservedInstancesWithContext), varargs...) } // ModifyReservedInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesRequest), arg0) } // ModifySnapshotAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttribute), arg0) } // ModifySnapshotAttributeWithContext mocks base method func (m *MockEC2API) ModifySnapshotAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifySnapshotAttributeWithContext), varargs...) } // ModifySnapshotAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeRequest), arg0) } // ModifySpotFleetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequest), arg0) } // ModifySpotFleetRequestWithContext mocks base method func (m *MockEC2API) ModifySpotFleetRequestWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifySpotFleetRequestWithContext), varargs...) } // ModifySpotFleetRequestRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestRequest), arg0) } // ModifySubnetAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), arg0) } // ModifySubnetAttributeWithContext mocks base method func (m *MockEC2API) ModifySubnetAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifySubnetAttributeWithContext), varargs...) } // ModifySubnetAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeRequest), arg0) } // ModifyTrafficMirrorFilterNetworkServices mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0) } // ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesWithContext), varargs...) } // ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0) } // ModifyTrafficMirrorFilterRule mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRule), arg0) } // ModifyTrafficMirrorFilterRuleWithContext mocks base method func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleWithContext), varargs...) } // ModifyTrafficMirrorFilterRuleRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0) } // ModifyTrafficMirrorSession mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSession), arg0) } // ModifyTrafficMirrorSessionWithContext mocks base method func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyTrafficMirrorSessionWithContext), varargs...) } // ModifyTrafficMirrorSessionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionRequest), arg0) } // ModifyTransitGatewayVpcAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachment), arg0) } // ModifyTransitGatewayVpcAttachmentWithContext mocks base method func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentWithContext), varargs...) } // ModifyTransitGatewayVpcAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0) } // ModifyVolume mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2API)(nil).ModifyVolume), arg0) } // ModifyVolumeWithContext mocks base method func (m *MockEC2API) ModifyVolumeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVolumeWithContext), varargs...) } // ModifyVolumeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeRequest), arg0) } // ModifyVolumeAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttribute), arg0) } // ModifyVolumeAttributeWithContext mocks base method func (m *MockEC2API) ModifyVolumeAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVolumeAttributeWithContext), varargs...) } // ModifyVolumeAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeRequest), arg0) } // ModifyVpcAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), arg0) } // ModifyVpcAttributeWithContext mocks base method func (m *MockEC2API) ModifyVpcAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcAttributeWithContext), varargs...) } // ModifyVpcAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeRequest), arg0) } // ModifyVpcEndpoint mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), arg0) } // ModifyVpcEndpointWithContext mocks base method func (m *MockEC2API) ModifyVpcEndpointWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcEndpointWithContext), varargs...) } // ModifyVpcEndpointRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointRequest), arg0) } // ModifyVpcEndpointConnectionNotification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotification), arg0) } // ModifyVpcEndpointConnectionNotificationWithContext mocks base method func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationWithContext), varargs...) } // ModifyVpcEndpointConnectionNotificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0) } // ModifyVpcEndpointServiceConfiguration mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfiguration), arg0) } // ModifyVpcEndpointServiceConfigurationWithContext mocks base method func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationWithContext), varargs...) } // ModifyVpcEndpointServiceConfigurationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0) } // ModifyVpcEndpointServicePermissions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissions), arg0) } // ModifyVpcEndpointServicePermissionsWithContext mocks base method func (m *MockEC2API) ModifyVpcEndpointServicePermissionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsWithContext), varargs...) } // ModifyVpcEndpointServicePermissionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0) } // ModifyVpcPeeringConnectionOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptions), arg0) } // ModifyVpcPeeringConnectionOptionsWithContext mocks base method func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsWithContext), varargs...) } // ModifyVpcPeeringConnectionOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0) } // ModifyVpcTenancy mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancy), arg0) } // ModifyVpcTenancyWithContext mocks base method func (m *MockEC2API) ModifyVpcTenancyWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpcTenancyWithContext), varargs...) } // ModifyVpcTenancyRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyRequest), arg0) } // ModifyVpnConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnection), arg0) } // ModifyVpnConnectionWithContext mocks base method func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpnConnectionWithContext), varargs...) } // ModifyVpnConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionRequest), arg0) } // ModifyVpnTunnelCertificate mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificate), arg0) } // ModifyVpnTunnelCertificateWithContext mocks base method func (m *MockEC2API) ModifyVpnTunnelCertificateWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpnTunnelCertificateWithContext), varargs...) } // ModifyVpnTunnelCertificateRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateRequest), arg0) } // ModifyVpnTunnelOptions mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptions), arg0) } // ModifyVpnTunnelOptionsWithContext mocks base method func (m *MockEC2API) ModifyVpnTunnelOptionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ModifyVpnTunnelOptionsWithContext), varargs...) } // ModifyVpnTunnelOptionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsRequest), arg0) } // MonitorInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2API)(nil).MonitorInstances), arg0) } // MonitorInstancesWithContext mocks base method func (m *MockEC2API) MonitorInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).MonitorInstancesWithContext), varargs...) } // MonitorInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesRequest), arg0) } // MoveAddressToVpc mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpc), arg0) } // MoveAddressToVpcWithContext mocks base method func (m *MockEC2API) MoveAddressToVpcWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).MoveAddressToVpcWithContext), varargs...) } // MoveAddressToVpcRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcRequest), arg0) } // ProvisionByoipCidr mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidr), arg0) } // ProvisionByoipCidrWithContext mocks base method func (m *MockEC2API) ProvisionByoipCidrWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ProvisionByoipCidrWithContext), varargs...) } // ProvisionByoipCidrRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrRequest), arg0) } // PurchaseHostReservation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservation), arg0) } // PurchaseHostReservationWithContext mocks base method func (m *MockEC2API) PurchaseHostReservationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).PurchaseHostReservationWithContext), varargs...) } // PurchaseHostReservationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationRequest), arg0) } // PurchaseReservedInstancesOffering mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOffering), arg0) } // PurchaseReservedInstancesOfferingWithContext mocks base method func (m *MockEC2API) PurchaseReservedInstancesOfferingWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).PurchaseReservedInstancesOfferingWithContext), varargs...) } // PurchaseReservedInstancesOfferingRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingRequest), arg0) } // PurchaseScheduledInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstances), arg0) } // PurchaseScheduledInstancesWithContext mocks base method func (m *MockEC2API) PurchaseScheduledInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).PurchaseScheduledInstancesWithContext), varargs...) } // PurchaseScheduledInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesRequest), arg0) } // RebootInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RebootInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2API)(nil).RebootInstances), arg0) } // RebootInstancesWithContext mocks base method func (m *MockEC2API) RebootInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RebootInstancesWithContext), varargs...) } // RebootInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesRequest), arg0) } // RegisterImage mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterImage(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2API)(nil).RegisterImage), arg0) } // RegisterImageWithContext mocks base method func (m *MockEC2API) RegisterImageWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RegisterImageWithContext), varargs...) } // RegisterImageRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterImageRequest), arg0) } // RegisterInstanceEventNotificationAttributes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributes", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributes), arg0) } // RegisterInstanceEventNotificationAttributesWithContext mocks base method func (m *MockEC2API) RegisterInstanceEventNotificationAttributesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesWithContext), varargs...) } // RegisterInstanceEventNotificationAttributesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterInstanceEventNotificationAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterInstanceEventNotificationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterInstanceEventNotificationAttributesRequest), arg0) } // RegisterTransitGatewayMulticastGroupMembers mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembers(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembers", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembers), arg0) } // RegisterTransitGatewayMulticastGroupMembersWithContext mocks base method func (m *MockEC2API) RegisterTransitGatewayMulticastGroupMembersWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersWithContext), varargs...) } // RegisterTransitGatewayMulticastGroupMembersRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupMembersRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupMembersRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupMembersRequest), arg0) } // RegisterTransitGatewayMulticastGroupSources mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSources(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSources", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSources), arg0) } // RegisterTransitGatewayMulticastGroupSourcesWithContext mocks base method func (m *MockEC2API) RegisterTransitGatewayMulticastGroupSourcesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesWithContext), varargs...) } // RegisterTransitGatewayMulticastGroupSourcesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RegisterTransitGatewayMulticastGroupSourcesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTransitGatewayMulticastGroupSourcesRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterTransitGatewayMulticastGroupSourcesRequest), arg0) } // RejectTransitGatewayPeeringAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachment), arg0) } // RejectTransitGatewayPeeringAttachmentWithContext mocks base method func (m *MockEC2API) RejectTransitGatewayPeeringAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentWithContext), varargs...) } // RejectTransitGatewayPeeringAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectTransitGatewayPeeringAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayPeeringAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayPeeringAttachmentRequest), arg0) } // RejectTransitGatewayVpcAttachment mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachment), arg0) } // RejectTransitGatewayVpcAttachmentWithContext mocks base method func (m *MockEC2API) RejectTransitGatewayVpcAttachmentWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentWithContext), varargs...) } // RejectTransitGatewayVpcAttachmentRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0) } // RejectVpcEndpointConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnections), arg0) } // RejectVpcEndpointConnectionsWithContext mocks base method func (m *MockEC2API) RejectVpcEndpointConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RejectVpcEndpointConnectionsWithContext), varargs...) } // RejectVpcEndpointConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsRequest), arg0) } // RejectVpcPeeringConnection mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnection), arg0) } // RejectVpcPeeringConnectionWithContext mocks base method func (m *MockEC2API) RejectVpcPeeringConnectionWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RejectVpcPeeringConnectionWithContext), varargs...) } // RejectVpcPeeringConnectionRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionRequest), arg0) } // ReleaseAddress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), arg0) } // ReleaseAddressWithContext mocks base method func (m *MockEC2API) ReleaseAddressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReleaseAddressWithContext), varargs...) } // ReleaseAddressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressRequest), arg0) } // ReleaseHosts mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2API)(nil).ReleaseHosts), arg0) } // ReleaseHostsWithContext mocks base method func (m *MockEC2API) ReleaseHostsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReleaseHostsWithContext), varargs...) } // ReleaseHostsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsRequest), arg0) } // ReplaceIamInstanceProfileAssociation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociation), arg0) } // ReplaceIamInstanceProfileAssociationWithContext mocks base method func (m *MockEC2API) ReplaceIamInstanceProfileAssociationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationWithContext), varargs...) } // ReplaceIamInstanceProfileAssociationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0) } // ReplaceNetworkAclAssociation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociation), arg0) } // ReplaceNetworkAclAssociationWithContext mocks base method func (m *MockEC2API) ReplaceNetworkAclAssociationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceNetworkAclAssociationWithContext), varargs...) } // ReplaceNetworkAclAssociationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationRequest), arg0) } // ReplaceNetworkAclEntry mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntry), arg0) } // ReplaceNetworkAclEntryWithContext mocks base method func (m *MockEC2API) ReplaceNetworkAclEntryWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceNetworkAclEntryWithContext), varargs...) } // ReplaceNetworkAclEntryRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryRequest), arg0) } // ReplaceRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), arg0) } // ReplaceRouteWithContext mocks base method func (m *MockEC2API) ReplaceRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceRouteWithContext), varargs...) } // ReplaceRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteRequest), arg0) } // ReplaceRouteTableAssociation mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociation), arg0) } // ReplaceRouteTableAssociationWithContext mocks base method func (m *MockEC2API) ReplaceRouteTableAssociationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceRouteTableAssociationWithContext), varargs...) } // ReplaceRouteTableAssociationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationRequest), arg0) } // ReplaceTransitGatewayRoute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRoute), arg0) } // ReplaceTransitGatewayRouteWithContext mocks base method func (m *MockEC2API) ReplaceTransitGatewayRouteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReplaceTransitGatewayRouteWithContext), varargs...) } // ReplaceTransitGatewayRouteRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteRequest), arg0) } // ReportInstanceStatus mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatus), arg0) } // ReportInstanceStatusWithContext mocks base method func (m *MockEC2API) ReportInstanceStatusWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ReportInstanceStatusWithContext), varargs...) } // ReportInstanceStatusRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusRequest), arg0) } // RequestSpotFleet mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleet), arg0) } // RequestSpotFleetWithContext mocks base method func (m *MockEC2API) RequestSpotFleetWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RequestSpotFleetWithContext), varargs...) } // RequestSpotFleetRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetRequest), arg0) } // RequestSpotInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstances), arg0) } // RequestSpotInstancesWithContext mocks base method func (m *MockEC2API) RequestSpotInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RequestSpotInstancesWithContext), varargs...) } // RequestSpotInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesRequest), arg0) } // ResetEbsDefaultKmsKeyId mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyId), arg0) } // ResetEbsDefaultKmsKeyIdWithContext mocks base method func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdWithContext), varargs...) } // ResetEbsDefaultKmsKeyIdRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0) } // ResetFpgaImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttribute), arg0) } // ResetFpgaImageAttributeWithContext mocks base method func (m *MockEC2API) ResetFpgaImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetFpgaImageAttributeWithContext), varargs...) } // ResetFpgaImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeRequest), arg0) } // ResetImageAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttribute), arg0) } // ResetImageAttributeWithContext mocks base method func (m *MockEC2API) ResetImageAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetImageAttributeWithContext), varargs...) } // ResetImageAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeRequest), arg0) } // ResetInstanceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttribute), arg0) } // ResetInstanceAttributeWithContext mocks base method func (m *MockEC2API) ResetInstanceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetInstanceAttributeWithContext), varargs...) } // ResetInstanceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeRequest), arg0) } // ResetNetworkInterfaceAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttribute), arg0) } // ResetNetworkInterfaceAttributeWithContext mocks base method func (m *MockEC2API) ResetNetworkInterfaceAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetNetworkInterfaceAttributeWithContext), varargs...) } // ResetNetworkInterfaceAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeRequest), arg0) } // ResetSnapshotAttribute mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttribute), arg0) } // ResetSnapshotAttributeWithContext mocks base method func (m *MockEC2API) ResetSnapshotAttributeWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).ResetSnapshotAttributeWithContext), varargs...) } // ResetSnapshotAttributeRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeRequest), arg0) } // RestoreAddressToClassic mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassic), arg0) } // RestoreAddressToClassicWithContext mocks base method func (m *MockEC2API) RestoreAddressToClassicWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RestoreAddressToClassicWithContext), varargs...) } // RestoreAddressToClassicRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicRequest), arg0) } // RevokeClientVpnIngress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngress), arg0) } // RevokeClientVpnIngressWithContext mocks base method func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RevokeClientVpnIngressWithContext), varargs...) } // RevokeClientVpnIngressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressRequest), arg0) } // RevokeSecurityGroupEgress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), arg0) } // RevokeSecurityGroupEgressWithContext mocks base method func (m *MockEC2API) RevokeSecurityGroupEgressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RevokeSecurityGroupEgressWithContext), varargs...) } // RevokeSecurityGroupEgressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressRequest), arg0) } // RevokeSecurityGroupIngress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), arg0) } // RevokeSecurityGroupIngressWithContext mocks base method func (m *MockEC2API) RevokeSecurityGroupIngressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RevokeSecurityGroupIngressWithContext), varargs...) } // RevokeSecurityGroupIngressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressRequest), arg0) } // RunInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RunInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), arg0) } // RunInstancesWithContext mocks base method func (m *MockEC2API) RunInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RunInstancesWithContext), varargs...) } // RunInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunInstancesRequest), arg0) } // RunScheduledInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstances), arg0) } // RunScheduledInstancesWithContext mocks base method func (m *MockEC2API) RunScheduledInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).RunScheduledInstancesWithContext), varargs...) } // RunScheduledInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesRequest), arg0) } // SearchLocalGatewayRoutes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchLocalGatewayRoutes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutes), arg0) } // SearchLocalGatewayRoutesWithContext mocks base method func (m *MockEC2API) SearchLocalGatewayRoutesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SearchLocalGatewayRoutesWithContext), varargs...) } // SearchLocalGatewayRoutesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchLocalGatewayRoutesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesRequest), arg0) } // SearchLocalGatewayRoutesPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchLocalGatewayRoutesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchLocalGatewayRoutesPages", reflect.TypeOf((*MockEC2API)(nil).SearchLocalGatewayRoutesPages), arg0, arg1) } // SearchLocalGatewayRoutesPagesWithContext mocks base method func (m *MockEC2API) SearchLocalGatewayRoutesPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SearchLocalGatewayRoutesPagesWithContext), varargs...) } // SearchTransitGatewayMulticastGroups mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroups", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroups), arg0) } // SearchTransitGatewayMulticastGroupsWithContext mocks base method func (m *MockEC2API) SearchTransitGatewayMulticastGroupsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsWithContext), varargs...) } // SearchTransitGatewayMulticastGroupsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsRequest), arg0) } // SearchTransitGatewayMulticastGroupsPages mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchTransitGatewayMulticastGroupsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayMulticastGroupsPages", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPages), arg0, arg1) } // SearchTransitGatewayMulticastGroupsPagesWithContext mocks base method func (m *MockEC2API) SearchTransitGatewayMulticastGroupsPagesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SearchTransitGatewayMulticastGroupsPagesWithContext), varargs...) } // SearchTransitGatewayRoutes mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutes), arg0) } // SearchTransitGatewayRoutesWithContext mocks base method func (m *MockEC2API) SearchTransitGatewayRoutesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SearchTransitGatewayRoutesWithContext), varargs...) } // SearchTransitGatewayRoutesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesRequest), arg0) } // SendDiagnosticInterrupt mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterrupt), arg0) } // SendDiagnosticInterruptWithContext mocks base method func (m *MockEC2API) SendDiagnosticInterruptWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).SendDiagnosticInterruptWithContext), varargs...) } // SendDiagnosticInterruptRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptRequest), arg0) } // StartInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StartInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2API)(nil).StartInstances), arg0) } // StartInstancesWithContext mocks base method func (m *MockEC2API) StartInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).StartInstancesWithContext), varargs...) } // StartInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StartInstancesRequest), arg0) } // StartVpcEndpointServicePrivateDnsVerification mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerification(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerification", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerification), arg0) } // StartVpcEndpointServicePrivateDnsVerificationWithContext mocks base method func (m *MockEC2API) StartVpcEndpointServicePrivateDnsVerificationWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationWithContext), varargs...) } // StartVpcEndpointServicePrivateDnsVerificationRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StartVpcEndpointServicePrivateDnsVerificationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartVpcEndpointServicePrivateDnsVerificationRequest", reflect.TypeOf((*MockEC2API)(nil).StartVpcEndpointServicePrivateDnsVerificationRequest), arg0) } // StopInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StopInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2API)(nil).StopInstances), arg0) } // StopInstancesWithContext mocks base method func (m *MockEC2API) StopInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).StopInstancesWithContext), varargs...) } // StopInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StopInstancesRequest), arg0) } // TerminateClientVpnConnections mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnections), arg0) } // TerminateClientVpnConnectionsWithContext mocks base method func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).TerminateClientVpnConnectionsWithContext), varargs...) } // TerminateClientVpnConnectionsRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsRequest), arg0) } // TerminateInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), arg0) } // TerminateInstancesWithContext mocks base method func (m *MockEC2API) TerminateInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).TerminateInstancesWithContext), varargs...) } // TerminateInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesRequest), arg0) } // UnassignIpv6Addresses mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6Addresses), arg0) } // UnassignIpv6AddressesWithContext mocks base method func (m *MockEC2API) UnassignIpv6AddressesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).UnassignIpv6AddressesWithContext), varargs...) } // UnassignIpv6AddressesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesRequest), arg0) } // UnassignPrivateIpAddresses mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddresses), arg0) } // UnassignPrivateIpAddressesWithContext mocks base method func (m *MockEC2API) UnassignPrivateIpAddressesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).UnassignPrivateIpAddressesWithContext), varargs...) } // UnassignPrivateIpAddressesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesRequest), arg0) } // UnmonitorInstances mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstances), arg0) } // UnmonitorInstancesWithContext mocks base method func (m *MockEC2API) UnmonitorInstancesWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).UnmonitorInstancesWithContext), varargs...) } // UnmonitorInstancesRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesRequest), arg0) } // UpdateSecurityGroupRuleDescriptionsEgress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0) } // UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressWithContext), varargs...) } // UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0) } // UpdateSecurityGroupRuleDescriptionsIngress mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0) } // UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressWithContext), varargs...) } // UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0) } // WithdrawByoipCidr mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidr), arg0) } // WithdrawByoipCidrWithContext mocks base method func (m *MockEC2API) WithdrawByoipCidrWithContext(arg0 aws.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 *MockEC2APIMockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrWithContext), varargs...) } // WithdrawByoipCidrRequest mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrRequest), arg0) } // WaitUntilBundleTaskComplete mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskComplete), arg0) } // WaitUntilBundleTaskCompleteWithContext mocks base method func (m *MockEC2API) WaitUntilBundleTaskCompleteWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilBundleTaskCompleteWithContext), varargs...) } // WaitUntilConversionTaskCancelled mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelled), arg0) } // WaitUntilConversionTaskCancelledWithContext mocks base method func (m *MockEC2API) WaitUntilConversionTaskCancelledWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilConversionTaskCancelledWithContext), varargs...) } // WaitUntilConversionTaskCompleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompleted), arg0) } // WaitUntilConversionTaskCompletedWithContext mocks base method func (m *MockEC2API) WaitUntilConversionTaskCompletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilConversionTaskCompletedWithContext), varargs...) } // WaitUntilConversionTaskDeleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeleted), arg0) } // WaitUntilConversionTaskDeletedWithContext mocks base method func (m *MockEC2API) WaitUntilConversionTaskDeletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilConversionTaskDeletedWithContext), varargs...) } // WaitUntilCustomerGatewayAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailable), arg0) } // WaitUntilCustomerGatewayAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilCustomerGatewayAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailableWithContext), varargs...) } // WaitUntilExportTaskCancelled mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelled), arg0) } // WaitUntilExportTaskCancelledWithContext mocks base method func (m *MockEC2API) WaitUntilExportTaskCancelledWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilExportTaskCancelledWithContext), varargs...) } // WaitUntilExportTaskCompleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompleted), arg0) } // WaitUntilExportTaskCompletedWithContext mocks base method func (m *MockEC2API) WaitUntilExportTaskCompletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilExportTaskCompletedWithContext), varargs...) } // WaitUntilImageAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailable), arg0) } // WaitUntilImageAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilImageAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilImageAvailableWithContext), varargs...) } // WaitUntilImageExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExists), arg0) } // WaitUntilImageExistsWithContext mocks base method func (m *MockEC2API) WaitUntilImageExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilImageExistsWithContext), varargs...) } // WaitUntilInstanceExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExists), arg0) } // WaitUntilInstanceExistsWithContext mocks base method func (m *MockEC2API) WaitUntilInstanceExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilInstanceExistsWithContext), varargs...) } // WaitUntilInstanceRunning mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunning), arg0) } // WaitUntilInstanceRunningWithContext mocks base method func (m *MockEC2API) WaitUntilInstanceRunningWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilInstanceRunningWithContext), varargs...) } // WaitUntilInstanceStatusOk mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOk), arg0) } // WaitUntilInstanceStatusOkWithContext mocks base method func (m *MockEC2API) WaitUntilInstanceStatusOkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilInstanceStatusOkWithContext), varargs...) } // WaitUntilInstanceStopped mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStopped), arg0) } // WaitUntilInstanceStoppedWithContext mocks base method func (m *MockEC2API) WaitUntilInstanceStoppedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilInstanceStoppedWithContext), varargs...) } // WaitUntilInstanceTerminated mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminated), arg0) } // WaitUntilInstanceTerminatedWithContext mocks base method func (m *MockEC2API) WaitUntilInstanceTerminatedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilInstanceTerminatedWithContext), varargs...) } // WaitUntilKeyPairExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExists), arg0) } // WaitUntilKeyPairExistsWithContext mocks base method func (m *MockEC2API) WaitUntilKeyPairExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilKeyPairExistsWithContext), varargs...) } // WaitUntilNatGatewayAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailable), arg0) } // WaitUntilNatGatewayAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilNatGatewayAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilNatGatewayAvailableWithContext), varargs...) } // WaitUntilNetworkInterfaceAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailable), arg0) } // WaitUntilNetworkInterfaceAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilNetworkInterfaceAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailableWithContext), varargs...) } // WaitUntilPasswordDataAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailable), arg0) } // WaitUntilPasswordDataAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilPasswordDataAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilPasswordDataAvailableWithContext), varargs...) } // WaitUntilSecurityGroupExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilSecurityGroupExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSecurityGroupExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSecurityGroupExists), arg0) } // WaitUntilSecurityGroupExistsWithContext mocks base method func (m *MockEC2API) WaitUntilSecurityGroupExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilSecurityGroupExistsWithContext), varargs...) } // WaitUntilSnapshotCompleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompleted), arg0) } // WaitUntilSnapshotCompletedWithContext mocks base method func (m *MockEC2API) WaitUntilSnapshotCompletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilSnapshotCompletedWithContext), varargs...) } // WaitUntilSpotInstanceRequestFulfilled mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0) } // WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilledWithContext), varargs...) } // WaitUntilSubnetAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailable), arg0) } // WaitUntilSubnetAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilSubnetAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilSubnetAvailableWithContext), varargs...) } // WaitUntilSystemStatusOk mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOk), arg0) } // WaitUntilSystemStatusOkWithContext mocks base method func (m *MockEC2API) WaitUntilSystemStatusOkWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilSystemStatusOkWithContext), varargs...) } // WaitUntilVolumeAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailable), arg0) } // WaitUntilVolumeAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilVolumeAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVolumeAvailableWithContext), varargs...) } // WaitUntilVolumeDeleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeleted), arg0) } // WaitUntilVolumeDeletedWithContext mocks base method func (m *MockEC2API) WaitUntilVolumeDeletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVolumeDeletedWithContext), varargs...) } // WaitUntilVolumeInUse mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUse), arg0) } // WaitUntilVolumeInUseWithContext mocks base method func (m *MockEC2API) WaitUntilVolumeInUseWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVolumeInUseWithContext), varargs...) } // WaitUntilVpcAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailable), arg0) } // WaitUntilVpcAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilVpcAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpcAvailableWithContext), varargs...) } // WaitUntilVpcExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExists), arg0) } // WaitUntilVpcExistsWithContext mocks base method func (m *MockEC2API) WaitUntilVpcExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpcExistsWithContext), varargs...) } // WaitUntilVpcPeeringConnectionDeleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0) } // WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeletedWithContext), varargs...) } // WaitUntilVpcPeeringConnectionExists mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExists), arg0) } // WaitUntilVpcPeeringConnectionExistsWithContext mocks base method func (m *MockEC2API) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExistsWithContext), varargs...) } // WaitUntilVpnConnectionAvailable mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailable), arg0) } // WaitUntilVpnConnectionAvailableWithContext mocks base method func (m *MockEC2API) WaitUntilVpnConnectionAvailableWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...) } // WaitUntilVpnConnectionDeleted mocks base method func (m *MockEC2API) 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 *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeleted), arg0) } // WaitUntilVpnConnectionDeletedWithContext mocks base method func (m *MockEC2API) WaitUntilVpnConnectionDeletedWithContext(arg0 aws.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 *MockEC2APIMockRecorder) 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((*MockEC2API)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...) } ================================================ FILE: ec2/vpc.go ================================================ package ec2 import ( "fmt" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" awsec2 "github.com/aws/aws-sdk-go/service/ec2" ) const ( defaultSecurityGroupName = "fargate-default" defaultSecurityGroupDescription = "Default Fargate CLI SG" defaultSecurityGroupIngressCIDR = "0.0.0.0/0" defaultSecurityGroupIngressProtocol = "-1" ) // GetDefaultSubnetIDs finds and returns the subnet IDs marked as default. func (ec2 SDKClient) GetDefaultSubnetIDs() ([]string, error) { var subnetIDs []string defaultFilter := &awsec2.Filter{ Name: aws.String("default-for-az"), Values: aws.StringSlice([]string{"true"}), } resp, err := ec2.client.DescribeSubnets( &awsec2.DescribeSubnetsInput{ Filters: []*awsec2.Filter{defaultFilter}, }, ) if err != nil { return subnetIDs, fmt.Errorf("could not retrieve default subnet IDs: %v", err) } for _, subnet := range resp.Subnets { subnetIDs = append(subnetIDs, aws.StringValue(subnet.SubnetId)) } return subnetIDs, nil } // GetDefaultSecurityGroupID returns the ID of the permissive security group created by default. func (ec2 SDKClient) GetDefaultSecurityGroupID() (string, error) { resp, err := ec2.client.DescribeSecurityGroups( &awsec2.DescribeSecurityGroupsInput{ GroupNames: aws.StringSlice([]string{defaultSecurityGroupName}), }, ) if err != nil { if aerr, ok := err.(awserr.Error); ok { if aerr.Code() == "InvalidGroup.NotFound" { return "", nil } } return "", fmt.Errorf("could not retrieve default security group ID (%s): %v", defaultSecurityGroupName, err) } return aws.StringValue(resp.SecurityGroups[0].GroupId), nil } // GetSubnetVPCID returns the VPC ID for a given subnet ID. func (ec2 SDKClient) GetSubnetVPCID(subnetID string) (string, error) { resp, err := ec2.client.DescribeSubnets( &awsec2.DescribeSubnetsInput{ SubnetIds: aws.StringSlice([]string{subnetID}), }, ) switch { case err != nil: return "", fmt.Errorf("could not find VPC ID for subnet ID %s: %v", subnetID, err) case len(resp.Subnets) == 0: return "", fmt.Errorf("could not find VPC ID: subnet ID %s not found", subnetID) default: return aws.StringValue(resp.Subnets[0].VpcId), nil } } // CreateDefaultSecurityGroup creates a new security group for use as the default. func (ec2 SDKClient) CreateDefaultSecurityGroup() (string, error) { resp, err := ec2.client.CreateSecurityGroup( &awsec2.CreateSecurityGroupInput{ GroupName: aws.String(defaultSecurityGroupName), Description: aws.String(defaultSecurityGroupDescription), }, ) if err != nil { return "", fmt.Errorf("could not create default security group (%s): %v", defaultSecurityGroupName, err) } return aws.StringValue(resp.GroupId), nil } // AuthorizeAllSecurityGroupIngress configures a security group to allow all ingress traffic. func (ec2 SDKClient) AuthorizeAllSecurityGroupIngress(groupID string) error { _, err := ec2.client.AuthorizeSecurityGroupIngress( &awsec2.AuthorizeSecurityGroupIngressInput{ CidrIp: aws.String(defaultSecurityGroupIngressCIDR), GroupId: aws.String(groupID), IpProtocol: aws.String(defaultSecurityGroupIngressProtocol), }, ) return err } ================================================ FILE: ec2/vpc_test.go ================================================ package ec2 import ( "errors" "testing" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" awsec2 "github.com/aws/aws-sdk-go/service/ec2" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/ec2/mock/sdk" ) func TestGetDefaultSubnetIDs(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() subnetID := "subnet-abcdef" subnet := &awsec2.Subnet{ SubnetId: aws.String(subnetID), } filter := &awsec2.Filter{ Name: aws.String("default-for-az"), Values: aws.StringSlice([]string{"true"}), } input := &awsec2.DescribeSubnetsInput{ Filters: []*awsec2.Filter{filter}, } output := &awsec2.DescribeSubnetsOutput{ Subnets: []*awsec2.Subnet{subnet}, } mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSubnets(input).Return(output, nil) out, err := ec2.GetDefaultSubnetIDs() if err != nil { t.Errorf("expected no error, got %v", err) } if out[0] != subnetID { t.Errorf("expected %s, got %s", subnetID, out[0]) } } func TestGetDefaultSubnetIDsError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSubnets(gomock.Any()).Return(&awsec2.DescribeSubnetsOutput{}, errors.New("boom")) out, err := ec2.GetDefaultSubnetIDs() if len(out) > 0 { t.Errorf("expected no results, got %v", out) } if err == nil { t.Errorf("expected error, got none") } } func TestGetDefaultSecurityGroupID(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() securityGroupID := "sg-abcdef" securityGroup := &awsec2.SecurityGroup{ GroupId: aws.String(securityGroupID), } input := &awsec2.DescribeSecurityGroupsInput{ GroupNames: aws.StringSlice([]string{"fargate-default"}), } output := &awsec2.DescribeSecurityGroupsOutput{ SecurityGroups: []*awsec2.SecurityGroup{securityGroup}, } mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSecurityGroups(input).Return(output, nil) out, err := ec2.GetDefaultSecurityGroupID() if err != nil { t.Errorf("expected no error, got %v", err) } if out != securityGroupID { t.Errorf("expected %s, got %s", securityGroupID, out) } } func TestGetDefaultSecurityGroupIDError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSecurityGroups(gomock.Any()).Return(&awsec2.DescribeSecurityGroupsOutput{}, errors.New("boom")) out, err := ec2.GetDefaultSecurityGroupID() if out != "" { t.Errorf("expected no result, got %v", out) } if err == nil { t.Errorf("expected error, got none") } } func TestGetDefaultSecurityGroupIDGroupNotFound(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} awserr := awserr.New("InvalidGroup.NotFound", "Group not found", errors.New("boom")) mockEC2Client.EXPECT().DescribeSecurityGroups(gomock.Any()).Return(&awsec2.DescribeSecurityGroupsOutput{}, awserr) out, err := ec2.GetDefaultSecurityGroupID() if err != nil { t.Errorf("expected no error, got %v", err) } if out != "" { t.Errorf("expected no result, got %v", out) } } func TestGetSubnetVPCID(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() subnetID := "subnet-abcdef" vpcID := "vpc-abcdef" subnet := &awsec2.Subnet{ VpcId: aws.String(vpcID), } input := &awsec2.DescribeSubnetsInput{ SubnetIds: aws.StringSlice([]string{subnetID}), } output := &awsec2.DescribeSubnetsOutput{ Subnets: []*awsec2.Subnet{subnet}, } mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSubnets(input).Return(output, nil) out, err := ec2.GetSubnetVPCID(subnetID) if err != nil { t.Errorf("expected no error, got %v", err) } if out != vpcID { t.Errorf("expected %s, got %s", vpcID, out) } } func TestGetSubnetVPCIDError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSubnets(gomock.Any()).Return(&awsec2.DescribeSubnetsOutput{}, errors.New("boom")) out, err := ec2.GetSubnetVPCID("subnet-abcdef") if err == nil { t.Errorf("expected error, got none") } if expected := errors.New("could not find VPC ID for subnet ID subnet-abcdef: boom"); err.Error() != expected.Error() { t.Errorf("expected error %v, got %v", expected, err) } if out != "" { t.Errorf("expected no result, got %s", out) } } func TestGetSubnetVPCIDSubnetNotFound(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() subnetID := "subnet-abcdef" mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().DescribeSubnets(gomock.Any()).Return(&awsec2.DescribeSubnetsOutput{}, nil) out, err := ec2.GetSubnetVPCID(subnetID) if err == nil { t.Errorf("expected error, got none") } if expected := errors.New("could not find VPC ID: subnet ID subnet-abcdef not found"); err.Error() != expected.Error() { t.Errorf("expected error %v, got %v", expected, err) } if out != "" { t.Errorf("expected no result, got %s", out) } } func TestCreateDefaultSecurityGroup(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() securityGroupID := "sg-abcdef" input := &awsec2.CreateSecurityGroupInput{ GroupName: aws.String("fargate-default"), Description: aws.String("Default Fargate CLI SG"), } output := &awsec2.CreateSecurityGroupOutput{ GroupId: aws.String(securityGroupID), } mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().CreateSecurityGroup(input).Return(output, nil) out, err := ec2.CreateDefaultSecurityGroup() if err != nil { t.Errorf("expected no error, got %v", err) } if out != securityGroupID { t.Errorf("expected %s, got %s", securityGroupID, out) } } func TestCreateDefaultSecurityGroupError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().CreateSecurityGroup(gomock.Any()).Return(&awsec2.CreateSecurityGroupOutput{}, errors.New("boom")) out, err := ec2.CreateDefaultSecurityGroup() if err == nil { t.Errorf("expected error, got none") } if expected := errors.New("could not create default security group (fargate-default): boom"); err.Error() != expected.Error() { t.Errorf("expected error %v, got %v", expected, err) } if out != "" { t.Errorf("expected no result, got %s", out) } } func TestAuthorizeAllSecurityGroupIngress(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() securityGroupID := "sg-abcdef" input := &awsec2.AuthorizeSecurityGroupIngressInput{ CidrIp: aws.String("0.0.0.0/0"), GroupId: aws.String("sg-abcdef"), IpProtocol: aws.String("-1"), } mockEC2Client := sdk.NewMockEC2API(mockCtrl) ec2 := SDKClient{client: mockEC2Client} mockEC2Client.EXPECT().AuthorizeSecurityGroupIngress(input).Return(&awsec2.AuthorizeSecurityGroupIngressOutput{}, nil) err := ec2.AuthorizeAllSecurityGroupIngress(securityGroupID) if err != nil { t.Errorf("expected no error, got %v", err) } } ================================================ FILE: ecr/main.go ================================================ package ecr import ( "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/ecr" ) type ECR struct { svc *ecr.ECR } func New(sess *session.Session) ECR { return ECR{ svc: ecr.New(sess), } } ================================================ FILE: ecr/repository.go ================================================ package ecr import ( "encoding/base64" "strings" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" awsecr "github.com/aws/aws-sdk-go/service/ecr" "github.com/awslabs/fargatecli/console" ) func (ecr *ECR) CreateRepository(repositoryName string) string { console.Debug("Creating Amazon ECR repository") resp, err := ecr.svc.CreateRepository( &awsecr.CreateRepositoryInput{ RepositoryName: aws.String(repositoryName), }, ) if err != nil { console.ErrorExit(err, "Couldn't create Amazon ECR repository") } console.Debug("Created Amazon ECR repository [%s]", *resp.Repository.RepositoryName) return aws.StringValue(resp.Repository.RepositoryUri) } func (ecr *ECR) IsRepositoryCreated(repositoryName string) bool { resp, err := ecr.svc.DescribeRepositories( &awsecr.DescribeRepositoriesInput{ RepositoryNames: aws.StringSlice([]string{repositoryName}), }, ) if err != nil { if awsErr, ok := err.(awserr.Error); ok { switch awsErr.Code() { case awsecr.ErrCodeRepositoryNotFoundException: return false default: console.ErrorExit(awsErr, "Could not create Cloudwatch Logs log group") } } console.ErrorExit(err, "Couldn't describe Amazon ECR repositories") } return len(resp.Repositories) == 1 } func (ecr *ECR) GetRepositoryUri(repositoryName string) string { resp, err := ecr.svc.DescribeRepositories( &awsecr.DescribeRepositoriesInput{ RepositoryNames: aws.StringSlice([]string{repositoryName}), }, ) if err != nil { console.ErrorExit(err, "Couldn't describe Amazon ECR repositories") } if len(resp.Repositories) != 1 { console.ErrorExit(err, "Couldn't find Amazon ECR repository: %s", repositoryName) } return aws.StringValue(resp.Repositories[0].RepositoryUri) } func (ecr *ECR) GetUsernameAndPassword() (username, password string) { resp, err := ecr.svc.GetAuthorizationToken( &awsecr.GetAuthorizationTokenInput{}, ) if err != nil { console.ErrorExit(err, "Couldn't get Amazon ECR authorization token") } token, _ := base64.StdEncoding.DecodeString(*resp.AuthorizationData[0].AuthorizationToken) s := strings.Split(string(token), ":") username = s[0] password = s[1] return } ================================================ FILE: ecs/cluster.go ================================================ package ecs import ( "github.com/aws/aws-sdk-go/aws" awsecs "github.com/aws/aws-sdk-go/service/ecs" ) func (ecs *ECS) CreateCluster() (string, error) { input := &awsecs.CreateClusterInput{ ClusterName: aws.String(ecs.ClusterName), } resp, err := ecs.svc.CreateCluster(input) if err != nil { return "", err } return aws.StringValue(resp.Cluster.ClusterArn), nil } ================================================ FILE: ecs/main.go ================================================ package ecs import ( "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/ecs" ) type ECS struct { svc *ecs.ECS ClusterName string } func New(sess *session.Session, clusterName string) ECS { return ECS{ ClusterName: clusterName, svc: ecs.New(sess), } } ================================================ FILE: ecs/service.go ================================================ package ecs import ( "fmt" "time" "github.com/aws/aws-sdk-go/aws" "github.com/aws/aws-sdk-go/aws/awserr" awsecs "github.com/aws/aws-sdk-go/service/ecs" "github.com/awslabs/fargatecli/console" ) type CreateServiceInput struct { Cluster string DesiredCount int64 Name string Port int64 SecurityGroupIds []string SubnetIds []string TargetGroupArn string TaskDefinitionArn string AssignPublicIpEnabled bool } type Service struct { Cluster string Cpu string Deployments []Deployment DesiredCount int64 EnvVars []EnvVar Events []Event Image string Memory string Name string PendingCount int64 RunningCount int64 SecurityGroupIds []string TargetGroupArn string TaskDefinitionArn string TaskRole string SubnetIds []string Status string } type Event struct { CreatedAt time.Time Message string } type Deployment struct { CreatedAt time.Time DesiredCount int64 Id string Image string PendingCount int64 RunningCount int64 Status string } func (s *Service) AddEvent(e Event) { s.Events = append(s.Events, e) } func (s *Service) AddDeployment(d Deployment) { s.Deployments = append(s.Deployments, d) } func (ecs *ECS) CreateService(input *CreateServiceInput) { console.Debug("Creating ECS service") assignPublicIP := awsecs.AssignPublicIpEnabled if !input.AssignPublicIpEnabled { assignPublicIP = awsecs.AssignPublicIpDisabled } createServiceInput := &awsecs.CreateServiceInput{ Cluster: aws.String(input.Cluster), DesiredCount: aws.Int64(input.DesiredCount), ServiceName: aws.String(input.Name), TaskDefinition: aws.String(input.TaskDefinitionArn), LaunchType: aws.String(awsecs.CompatibilityFargate), NetworkConfiguration: &awsecs.NetworkConfiguration{ AwsvpcConfiguration: &awsecs.AwsVpcConfiguration{ AssignPublicIp: aws.String(assignPublicIP), Subnets: aws.StringSlice(input.SubnetIds), SecurityGroups: aws.StringSlice(input.SecurityGroupIds), }, }, } if input.TargetGroupArn != "" && input.Port > 0 { createServiceInput.SetLoadBalancers( []*awsecs.LoadBalancer{ &awsecs.LoadBalancer{ TargetGroupArn: aws.String(input.TargetGroupArn), ContainerPort: aws.Int64(input.Port), ContainerName: aws.String(input.Name), }, }, ) } _, err := ecs.svc.CreateService(createServiceInput) if err != nil { console.ErrorExit(err, "Couldn't create ECS service") } console.Debug("Created ECS service [%s]", input.Name) return } func (ecs *ECS) DescribeService(serviceName string) Service { services := ecs.DescribeServices([]string{serviceName}) if len(services) == 0 { console.ErrorExit(fmt.Errorf("Could not find %s", serviceName), "Could not describe ECS service") } return services[0] } func (ecs *ECS) GetDesiredCount(serviceName string) int64 { service := ecs.DescribeService(serviceName) return service.DesiredCount } func (ecs *ECS) SetDesiredCount(serviceName string, desiredCount int64) { _, err := ecs.svc.UpdateService( &awsecs.UpdateServiceInput{ Cluster: aws.String(ecs.ClusterName), Service: aws.String(serviceName), DesiredCount: aws.Int64(desiredCount), }, ) if err != nil { console.ErrorExit(err, "Could not scale ECS service") } } func (ecs *ECS) DestroyService(serviceName string) { _, err := ecs.svc.DeleteService( &awsecs.DeleteServiceInput{ Cluster: aws.String(ecs.ClusterName), Service: aws.String(serviceName), }, ) if err != nil { console.ErrorExit(err, "Could not destroy ECS service") } } func (ecs *ECS) ListServices() []Service { var services []Service var serviceArnBatches [][]string err := ecs.svc.ListServicesPages( &awsecs.ListServicesInput{ Cluster: aws.String(ecs.ClusterName), LaunchType: aws.String(awsecs.CompatibilityFargate), }, func(resp *awsecs.ListServicesOutput, lastPage bool) bool { if len(resp.ServiceArns) > 0 { serviceArnBatches = append(serviceArnBatches, aws.StringValueSlice(resp.ServiceArns)) } return true }, ) if err != nil { console.ErrorExit(err, "Could not list ECS services") } if len(serviceArnBatches) > 0 { for _, serviceArnBatch := range serviceArnBatches { for _, service := range ecs.DescribeServices(serviceArnBatch) { services = append(services, service) } } } return services } func (ecs *ECS) DescribeServices(serviceArns []string) []Service { var services []Service resp, err := ecs.svc.DescribeServices( &awsecs.DescribeServicesInput{ Cluster: aws.String(ecs.ClusterName), Services: aws.StringSlice(serviceArns), }, ) if err != nil { console.ErrorExit(err, "Could not describe ECS services") } for _, service := range resp.Services { var securityGroupIds, subnetIds []*string if config := service.NetworkConfiguration.AwsvpcConfiguration; config != nil { securityGroupIds = config.SecurityGroups subnetIds = config.Subnets } s := Service{ DesiredCount: aws.Int64Value(service.DesiredCount), Name: aws.StringValue(service.ServiceName), PendingCount: aws.Int64Value(service.PendingCount), RunningCount: aws.Int64Value(service.RunningCount), SecurityGroupIds: aws.StringValueSlice(securityGroupIds), Status: aws.StringValue(service.Status), SubnetIds: aws.StringValueSlice(subnetIds), TaskDefinitionArn: aws.StringValue(service.TaskDefinition), } taskDefinition := ecs.DescribeTaskDefinition(aws.StringValue(service.TaskDefinition)) s.Cpu = aws.StringValue(taskDefinition.Cpu) s.Memory = aws.StringValue(taskDefinition.Memory) s.TaskRole = aws.StringValue(taskDefinition.TaskRoleArn) if len(service.LoadBalancers) > 0 { s.TargetGroupArn = aws.StringValue(service.LoadBalancers[0].TargetGroupArn) } if len(taskDefinition.ContainerDefinitions) > 0 { s.Image = aws.StringValue(taskDefinition.ContainerDefinitions[0].Image) for _, env := range taskDefinition.ContainerDefinitions[0].Environment { s.EnvVars = append( s.EnvVars, EnvVar{ Key: aws.StringValue(env.Name), Value: aws.StringValue(env.Value), }, ) } } for _, event := range service.Events { s.AddEvent( Event{ CreatedAt: aws.TimeValue(event.CreatedAt), Message: aws.StringValue(event.Message), }, ) } for _, d := range service.Deployments { deployment := Deployment{ Status: aws.StringValue(d.Status), DesiredCount: aws.Int64Value(d.DesiredCount), PendingCount: aws.Int64Value(d.PendingCount), RunningCount: aws.Int64Value(d.RunningCount), CreatedAt: aws.TimeValue(d.CreatedAt), Id: ecs.getDeploymentId(aws.StringValue(d.TaskDefinition)), } deploymentTaskDefinition := ecs.DescribeTaskDefinition(aws.StringValue(d.TaskDefinition)) deployment.Image = aws.StringValue(deploymentTaskDefinition.ContainerDefinitions[0].Image) s.AddDeployment(deployment) } services = append(services, s) } return services } func (ecs *ECS) UpdateServiceTaskDefinition(serviceName, taskDefinitionArn string) { _, err := ecs.svc.UpdateService( &awsecs.UpdateServiceInput{ Cluster: aws.String(ecs.ClusterName), Service: aws.String(serviceName), TaskDefinition: aws.String(taskDefinitionArn), }, ) if err != nil { console.ErrorExit(err, "Could not update ECS service task definition") } } func (ecs *ECS) RestartService(serviceName string) { _, err := ecs.svc.UpdateService( &awsecs.UpdateServiceInput{ Cluster: aws.String(ecs.ClusterName), Service: aws.String(serviceName), ForceNewDeployment: aws.Bool(true), }, ) if err != nil { if aerr, ok := err.(awserr.Error); ok { switch aerr.Code() { case "ServiceNotFoundException": console.IssueExit("Service %s not found", serviceName) default: console.ErrorExit(err, "Could not restart service") } } console.ErrorExit(err, "Could not restart service") } } ================================================ FILE: ecs/task.go ================================================ package ecs import ( "fmt" "regexp" "strings" "time" "github.com/aws/aws-sdk-go/aws" awsecs "github.com/aws/aws-sdk-go/service/ecs" "github.com/awslabs/fargatecli/console" ) const ( detailNetworkInterfaceId = "networkInterfaceId" detailSubnetId = "subnetId" startedByFormat = "fargate:%s" taskGroupStartedByPattern = "fargate:(.*)" ) type Task struct { Cpu string CreatedAt time.Time DeploymentId string DesiredStatus string EniId string EnvVars []EnvVar Image string LastStatus string Memory string SecurityGroupIds []string StartedBy string SubnetId string TaskId string TaskRole string } func (t *Task) RunningFor() time.Duration { return time.Now().Sub(t.CreatedAt).Truncate(time.Second) } type TaskGroup struct { TaskGroupName string Instances int64 } type RunTaskInput struct { ClusterName string Count int64 SecurityGroupIds []string SubnetIds []string TaskDefinitionArn string TaskName string } func (ecs *ECS) RunTask(i *RunTaskInput) { _, err := ecs.svc.RunTask( &awsecs.RunTaskInput{ Cluster: aws.String(i.ClusterName), Count: aws.Int64(i.Count), TaskDefinition: aws.String(i.TaskDefinitionArn), LaunchType: aws.String(awsecs.CompatibilityFargate), StartedBy: aws.String(fmt.Sprintf(startedByFormat, i.TaskName)), NetworkConfiguration: &awsecs.NetworkConfiguration{ AwsvpcConfiguration: &awsecs.AwsVpcConfiguration{ AssignPublicIp: aws.String(awsecs.AssignPublicIpEnabled), Subnets: aws.StringSlice(i.SubnetIds), SecurityGroups: aws.StringSlice(i.SecurityGroupIds), }, }, }, ) if err != nil { console.ErrorExit(err, "Could not run ECS task") } } func (ecs *ECS) DescribeTasksForService(serviceName string) []Task { return ecs.listTasks( &awsecs.ListTasksInput{ Cluster: aws.String(ecs.ClusterName), LaunchType: aws.String(awsecs.CompatibilityFargate), ServiceName: aws.String(serviceName), }, ) } func (ecs *ECS) DescribeTasksForTaskGroup(taskGroupName string) []Task { return ecs.listTasks( &awsecs.ListTasksInput{ StartedBy: aws.String(fmt.Sprintf(startedByFormat, taskGroupName)), Cluster: aws.String(ecs.ClusterName), }, ) } func (ecs *ECS) ListTaskGroups() []*TaskGroup { var taskGroups []*TaskGroup taskGroupStartedByRegexp := regexp.MustCompile(taskGroupStartedByPattern) input := &awsecs.ListTasksInput{ Cluster: aws.String(ecs.ClusterName), } OUTER: for _, task := range ecs.listTasks(input) { matches := taskGroupStartedByRegexp.FindStringSubmatch(task.StartedBy) if len(matches) == 2 { taskGroupName := matches[1] for _, taskGroup := range taskGroups { if taskGroup.TaskGroupName == taskGroupName { taskGroup.Instances++ continue OUTER } } taskGroups = append( taskGroups, &TaskGroup{ TaskGroupName: taskGroupName, Instances: 1, }, ) } } return taskGroups } func (ecs *ECS) StopTasks(taskIds []string) { for _, taskId := range taskIds { ecs.StopTask(taskId) } } func (ecs *ECS) StopTask(taskId string) { _, err := ecs.svc.StopTask( &awsecs.StopTaskInput{ Cluster: aws.String(ecs.ClusterName), Task: aws.String(taskId), }, ) if err != nil { console.ErrorExit(err, "Could not stop ECS task") } } func (ecs *ECS) listTasks(input *awsecs.ListTasksInput) []Task { var tasks []Task var taskArnBatches [][]string err := ecs.svc.ListTasksPages( input, func(resp *awsecs.ListTasksOutput, lastPage bool) bool { if len(resp.TaskArns) > 0 { taskArnBatches = append(taskArnBatches, aws.StringValueSlice(resp.TaskArns)) } return true }, ) if err != nil { console.ErrorExit(err, "Could not list ECS tasks") } if len(taskArnBatches) > 0 { for _, taskArnBatch := range taskArnBatches { for _, task := range ecs.DescribeTasks(taskArnBatch) { tasks = append(tasks, task) } } } return tasks } func (ecs *ECS) DescribeTasks(taskIds []string) []Task { var tasks []Task if len(taskIds) == 0 { return tasks } resp, err := ecs.svc.DescribeTasks( &awsecs.DescribeTasksInput{ Cluster: aws.String(ecs.ClusterName), Tasks: aws.StringSlice(taskIds), }, ) if err != nil { console.ErrorExit(err, "Could not describe ECS tasks") } for _, t := range resp.Tasks { taskArn := aws.StringValue(t.TaskArn) contents := strings.Split(taskArn, "/") taskId := contents[len(contents)-1] task := Task{ Cpu: aws.StringValue(t.Cpu), CreatedAt: aws.TimeValue(t.CreatedAt), DeploymentId: ecs.getDeploymentId(aws.StringValue(t.TaskDefinitionArn)), DesiredStatus: aws.StringValue(t.DesiredStatus), LastStatus: aws.StringValue(t.LastStatus), Memory: aws.StringValue(t.Memory), TaskId: taskId, StartedBy: aws.StringValue(t.StartedBy), } taskDefinition := ecs.DescribeTaskDefinition(aws.StringValue(t.TaskDefinitionArn)) task.Image = aws.StringValue(taskDefinition.ContainerDefinitions[0].Image) task.TaskRole = aws.StringValue(taskDefinition.TaskRoleArn) for _, environment := range taskDefinition.ContainerDefinitions[0].Environment { task.EnvVars = append( task.EnvVars, EnvVar{ Key: aws.StringValue(environment.Name), Value: aws.StringValue(environment.Value), }, ) } if len(t.Attachments) == 1 { for _, detail := range t.Attachments[0].Details { switch aws.StringValue(detail.Name) { case detailNetworkInterfaceId: task.EniId = aws.StringValue(detail.Value) case detailSubnetId: task.SubnetId = aws.StringValue(detail.Value) } } } tasks = append(tasks, task) } return tasks } ================================================ FILE: ecs/task_definition.go ================================================ package ecs import ( "fmt" "strings" "github.com/aws/aws-sdk-go/aws" awsecs "github.com/aws/aws-sdk-go/service/ecs" "github.com/awslabs/fargatecli/console" ) const logStreamPrefix = "fargate" var taskDefinitionCache = make(map[string]*awsecs.TaskDefinition) type CreateTaskDefinitionInput struct { Cpu string EnvVars []EnvVar ExecutionRoleArn string Image string Memory string Name string Port int64 LogGroupName string LogRegion string TaskRole string Type string TaskCommand []string } type EnvVar struct { Key string Value string } func (ecs *ECS) CreateTaskDefinition(input *CreateTaskDefinitionInput) string { console.Debug("Creating ECS task definition") logConfiguration := &awsecs.LogConfiguration{ LogDriver: aws.String(awsecs.LogDriverAwslogs), Options: map[string]*string{ "awslogs-region": aws.String(input.LogRegion), "awslogs-group": aws.String(input.LogGroupName), "awslogs-stream-prefix": aws.String(logStreamPrefix), }, } containerDefinition := &awsecs.ContainerDefinition{ Environment: input.Environment(), Essential: aws.Bool(true), Image: aws.String(input.Image), LogConfiguration: logConfiguration, Name: aws.String(input.Name), Command: aws.StringSlice(input.TaskCommand), } if input.Port != 0 { containerDefinition.SetPortMappings( []*awsecs.PortMapping{ &awsecs.PortMapping{ ContainerPort: aws.Int64(int64(input.Port)), }, }, ) } resp, err := ecs.svc.RegisterTaskDefinition( &awsecs.RegisterTaskDefinitionInput{ ContainerDefinitions: []*awsecs.ContainerDefinition{containerDefinition}, Cpu: aws.String(input.Cpu), ExecutionRoleArn: aws.String(input.ExecutionRoleArn), Family: aws.String(fmt.Sprintf("%s_%s", input.Type, input.Name)), Memory: aws.String(input.Memory), NetworkMode: aws.String(awsecs.NetworkModeAwsvpc), RequiresCompatibilities: aws.StringSlice([]string{awsecs.CompatibilityFargate}), TaskRoleArn: aws.String(input.TaskRole), }, ) if err != nil { console.ErrorExit(err, "Couldn't register ECS task definition") } td := resp.TaskDefinition console.Debug("Created ECS task definition [%s:%d]", aws.StringValue(td.Family), aws.Int64Value(td.Revision)) return aws.StringValue(td.TaskDefinitionArn) } func (input *CreateTaskDefinitionInput) Environment() []*awsecs.KeyValuePair { var environment []*awsecs.KeyValuePair for _, envVar := range input.EnvVars { environment = append(environment, &awsecs.KeyValuePair{ Name: aws.String(envVar.Key), Value: aws.String(envVar.Value), }, ) } return environment } func (ecs *ECS) DescribeTaskDefinition(taskDefinitionArn string) *awsecs.TaskDefinition { if taskDefinitionCache[taskDefinitionArn] != nil { return taskDefinitionCache[taskDefinitionArn] } resp, err := ecs.svc.DescribeTaskDefinition( &awsecs.DescribeTaskDefinitionInput{ TaskDefinition: aws.String(taskDefinitionArn), }, ) if err != nil { console.ErrorExit(err, "Could not describe ECS task definition") } taskDefinitionCache[taskDefinitionArn] = resp.TaskDefinition return taskDefinitionCache[taskDefinitionArn] } func (ecs *ECS) UpdateTaskDefinitionImage(taskDefinitionArn, image string) string { taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) taskDefinition.ContainerDefinitions[0].Image = aws.String(image) resp, err := ecs.svc.RegisterTaskDefinition( &awsecs.RegisterTaskDefinitionInput{ ContainerDefinitions: taskDefinition.ContainerDefinitions, Cpu: taskDefinition.Cpu, ExecutionRoleArn: taskDefinition.ExecutionRoleArn, Family: taskDefinition.Family, Memory: taskDefinition.Memory, NetworkMode: taskDefinition.NetworkMode, RequiresCompatibilities: taskDefinition.RequiresCompatibilities, TaskRoleArn: taskDefinition.TaskRoleArn, Volumes: taskDefinition.Volumes, }, ) if err != nil { console.ErrorExit(err, "Could not register ECS task definition") } return aws.StringValue(resp.TaskDefinition.TaskDefinitionArn) } func (ecs *ECS) AddEnvVarsToTaskDefinition(taskDefinitionArn string, envVars []EnvVar) string { taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) for _, envVar := range envVars { keyValuePair := &awsecs.KeyValuePair{ Name: aws.String(envVar.Key), Value: aws.String(envVar.Value), } taskDefinition.ContainerDefinitions[0].Environment = append( taskDefinition.ContainerDefinitions[0].Environment, keyValuePair, ) } resp, err := ecs.svc.RegisterTaskDefinition( &awsecs.RegisterTaskDefinitionInput{ ContainerDefinitions: taskDefinition.ContainerDefinitions, Cpu: taskDefinition.Cpu, ExecutionRoleArn: taskDefinition.ExecutionRoleArn, Family: taskDefinition.Family, Memory: taskDefinition.Memory, NetworkMode: taskDefinition.NetworkMode, RequiresCompatibilities: taskDefinition.RequiresCompatibilities, TaskRoleArn: taskDefinition.TaskRoleArn, Volumes: taskDefinition.Volumes, }, ) if err != nil { console.ErrorExit(err, "Could not register ECS task definition") } return aws.StringValue(resp.TaskDefinition.TaskDefinitionArn) } func (ecs *ECS) RemoveEnvVarsFromTaskDefinition(taskDefinitionArn string, keys []string) string { var newEnvironment []*awsecs.KeyValuePair taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) environment := taskDefinition.ContainerDefinitions[0].Environment for _, keyValuePair := range environment { for _, key := range keys { if aws.StringValue(keyValuePair.Name) == key { continue } newEnvironment = append(newEnvironment, keyValuePair) } } taskDefinition.ContainerDefinitions[0].Environment = newEnvironment resp, err := ecs.svc.RegisterTaskDefinition( &awsecs.RegisterTaskDefinitionInput{ ContainerDefinitions: taskDefinition.ContainerDefinitions, Cpu: taskDefinition.Cpu, ExecutionRoleArn: taskDefinition.ExecutionRoleArn, Family: taskDefinition.Family, Memory: taskDefinition.Memory, NetworkMode: taskDefinition.NetworkMode, RequiresCompatibilities: taskDefinition.RequiresCompatibilities, TaskRoleArn: taskDefinition.TaskRoleArn, Volumes: taskDefinition.Volumes, }, ) if err != nil { console.ErrorExit(err, "Could not register ECS task definition") } return aws.StringValue(resp.TaskDefinition.TaskDefinitionArn) } func (ecs *ECS) GetEnvVarsFromTaskDefinition(taskDefinitionArn string) []EnvVar { var envVars []EnvVar taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) for _, keyValuePair := range taskDefinition.ContainerDefinitions[0].Environment { envVars = append(envVars, EnvVar{ Key: aws.StringValue(keyValuePair.Name), Value: aws.StringValue(keyValuePair.Value), }, ) } return envVars } func (ecs *ECS) UpdateTaskDefinitionCpuAndMemory(taskDefinitionArn, cpu, memory string) string { taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) if cpu != "" { taskDefinition.Cpu = aws.String(cpu) } if memory != "" { taskDefinition.Memory = aws.String(memory) } resp, err := ecs.svc.RegisterTaskDefinition( &awsecs.RegisterTaskDefinitionInput{ ContainerDefinitions: taskDefinition.ContainerDefinitions, Cpu: taskDefinition.Cpu, ExecutionRoleArn: taskDefinition.ExecutionRoleArn, Family: taskDefinition.Family, Memory: taskDefinition.Memory, NetworkMode: taskDefinition.NetworkMode, RequiresCompatibilities: taskDefinition.RequiresCompatibilities, TaskRoleArn: taskDefinition.TaskRoleArn, Volumes: taskDefinition.Volumes, }, ) if err != nil { console.ErrorExit(err, "Could not register ECS task definition") } return aws.StringValue(resp.TaskDefinition.TaskDefinitionArn) } func (ecs *ECS) getDeploymentId(taskDefinitionArn string) string { contents := strings.Split(taskDefinitionArn, ":") return contents[len(contents)-1] } func (ecs *ECS) GetCpuAndMemoryFromTaskDefinition(taskDefinitionArn string) (string, string) { taskDefinition := ecs.DescribeTaskDefinition(taskDefinitionArn) return aws.StringValue(taskDefinition.Cpu), aws.StringValue(taskDefinition.Memory) } ================================================ FILE: elbv2/listener.go ================================================ package elbv2 import ( "fmt" "sort" "strconv" "strings" "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/awslabs/fargatecli/console" ) // Listener accepts incoming traffic on a load balancer based upon the provided routing rules. type Listener struct { ARN string CertificateARNs []string Port int64 Protocol string Rules []Rule } // String returns a friendly representation of the listener. func (l Listener) String() string { return fmt.Sprintf("%s:%d", l.Protocol, l.Port) } // Listeners is a collection of listeners. type Listeners []Listener // Listeners returns a comma-separated friendly representation of the listeners. func (l Listeners) String() string { var listenerStrings []string for _, listener := range l { listenerStrings = append(listenerStrings, listener.String()) } return strings.Join(listenerStrings, ", ") } // Rule defines a routing rule defining how traffic should be routed to a listener. type Rule struct { ARN string IsDefault bool Priority int TargetGroupARN string Type string Value string } // String returns a friendly representation of a rule. func (r Rule) String() string { return strings.Join([]string{r.Type, r.Value}, "=") } // CreateListenerParameters are the parameters required to create a new listener. type CreateListenerParameters struct { CertificateARNs []string DefaultTargetGroupARN string LoadBalancerARN string Port int64 Protocol string } // SetCertificateARNs sets the certificate ARNs with the given ARNs. func (input *CreateListenerParameters) SetCertificateARNs(arns []string) { input.CertificateARNs = arns } // CreateListener creates a new listener and returns the listener ARN if successfully created. func (elbv2 SDKClient) CreateListener(p CreateListenerParameters) (string, error) { action := &awselbv2.Action{ TargetGroupArn: aws.String(p.DefaultTargetGroupARN), Type: aws.String(awselbv2.ActionTypeEnumForward), } i := &awselbv2.CreateListenerInput{ Port: aws.Int64(p.Port), Protocol: aws.String(p.Protocol), LoadBalancerArn: aws.String(p.LoadBalancerARN), DefaultActions: []*awselbv2.Action{action}, } if len(p.CertificateARNs) > 0 { certificates := []*awselbv2.Certificate{} for _, certificateARN := range p.CertificateARNs { certificates = append(certificates, &awselbv2.Certificate{ CertificateArn: aws.String(certificateARN), }, ) } i.SetCertificates(certificates) } resp, err := elbv2.client.CreateListener(i) if err != nil { return "", err } return aws.StringValue(resp.Listeners[0].ListenerArn), nil } // DescribeListeners returns all of the listeners for a given load balancer ARN. func (elbv2 SDKClient) DescribeListeners(lbARN string) (Listeners, error) { var listeners []Listener input := &awselbv2.DescribeListenersInput{ LoadBalancerArn: aws.String(lbARN), } err := elbv2.client.DescribeListenersPages( input, func(resp *awselbv2.DescribeListenersOutput, lastPage bool) bool { for _, l := range resp.Listeners { listener := Listener{ ARN: aws.StringValue(l.ListenerArn), Port: aws.Int64Value(l.Port), Protocol: aws.StringValue(l.Protocol), } for _, certificate := range l.Certificates { listener.CertificateARNs = append(listener.CertificateARNs, aws.StringValue(certificate.CertificateArn)) } listeners = append(listeners, listener) } return true }, ) return listeners, err } func (elbv2 SDKClient) ModifyLoadBalancerDefaultAction(lbARN, targetGroupARN string) { for _, listener := range elbv2.GetListeners(lbARN) { elbv2.ModifyListenerDefaultAction(listener.ARN, targetGroupARN) } } func (elbv2 SDKClient) ModifyListenerDefaultAction(listenerARN, targetGroupARN string) { action := &awselbv2.Action{ TargetGroupArn: aws.String(targetGroupARN), Type: aws.String(awselbv2.ActionTypeEnumForward), } elbv2.client.ModifyListener( &awselbv2.ModifyListenerInput{ ListenerArn: aws.String(listenerARN), DefaultActions: []*awselbv2.Action{action}, }, ) } func (elbv2 SDKClient) AddRule(lbARN, targetGroupARN string, rule Rule) { console.Debug("Adding ELB listener rule [%s=%s]", rule.Type, rule.Value) listeners := elbv2.GetListeners(lbARN) for _, listener := range listeners { elbv2.AddRuleToListener(listener.ARN, targetGroupARN, rule) } } func (elbv2 SDKClient) AddRuleToListener(listenerARN, targetGroupARN string, rule Rule) { var ruleType string if rule.Type == "HOST" { ruleType = "host-header" } else { ruleType = "path-pattern" } ruleCondition := &awselbv2.RuleCondition{ Field: aws.String(ruleType), Values: aws.StringSlice([]string{rule.Value}), } highestPriority := elbv2.GetHighestPriorityFromListener(listenerARN) priority := highestPriority + 10 action := &awselbv2.Action{ TargetGroupArn: aws.String(targetGroupARN), Type: aws.String(awselbv2.ActionTypeEnumForward), } elbv2.client.CreateRule( &awselbv2.CreateRuleInput{ Priority: aws.Int64(priority), ListenerArn: aws.String(listenerARN), Actions: []*awselbv2.Action{action}, Conditions: []*awselbv2.RuleCondition{ruleCondition}, }, ) } func (elbv2 SDKClient) DescribeRules(listenerARN string) []Rule { var rules []Rule resp, err := elbv2.client.DescribeRules( &awselbv2.DescribeRulesInput{ ListenerArn: aws.String(listenerARN), }, ) if err != nil { console.ErrorExit(err, "Could not describe ELB rules") } for _, r := range resp.Rules { for _, c := range r.Conditions { var field string switch aws.StringValue(c.Field) { case "host-header": field = "HOST" case "path-pattern": field = "PATH" } for _, v := range c.Values { priority, _ := strconv.Atoi(aws.StringValue(r.Priority)) rule := Rule{ ARN: aws.StringValue(r.RuleArn), Priority: priority, TargetGroupARN: aws.StringValue(r.Actions[0].TargetGroupArn), Type: field, Value: aws.StringValue(v), } rules = append(rules, rule) } } if aws.BoolValue(r.IsDefault) == true { rule := Rule{ TargetGroupARN: aws.StringValue(r.Actions[0].TargetGroupArn), Type: "DEFAULT", IsDefault: true, } rules = append(rules, rule) } } return rules } func (elbv2 SDKClient) GetHighestPriorityFromListener(listenerARN string) int64 { var priorities []int resp, err := elbv2.client.DescribeRules( &awselbv2.DescribeRulesInput{ ListenerArn: aws.String(listenerARN), }, ) if err != nil { console.ErrorExit(err, "Could not retrieve ELB listener rules") } for _, rule := range resp.Rules { priority, _ := strconv.Atoi(aws.StringValue(rule.Priority)) priorities = append(priorities, priority) } sort.Ints(priorities) return int64(priorities[len(priorities)-1]) } func (elbv2 SDKClient) GetListeners(lbARN string) []Listener { var listeners []Listener input := &awselbv2.DescribeListenersInput{ LoadBalancerArn: aws.String(lbARN), } err := elbv2.client.DescribeListenersPages( input, func(resp *awselbv2.DescribeListenersOutput, lastPage bool) bool { for _, l := range resp.Listeners { listener := Listener{ ARN: aws.StringValue(l.ListenerArn), Port: aws.Int64Value(l.Port), Protocol: aws.StringValue(l.Protocol), } for _, certificate := range l.Certificates { listener.CertificateARNs = append( listener.CertificateARNs, aws.StringValue(certificate.CertificateArn), ) } listeners = append(listeners, listener) } return true }, ) if err != nil { console.ErrorExit(err, "Could not retrieve ELB listeners") } return listeners } func (elbv2 SDKClient) DeleteRule(ruleARN string) { _, err := elbv2.client.DeleteRule( &awselbv2.DeleteRuleInput{ RuleArn: aws.String(ruleARN), }, ) if err != nil { console.ErrorExit(err, "Could not delete ELB rule") } } ================================================ FILE: elbv2/listener_test.go ================================================ package elbv2 import ( "reflect" "testing" "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/elbv2/mock/sdk" ) func TestListenerString(t *testing.T) { listener := Listener{ Port: 80, Protocol: "HTTP", } if expected, got := "HTTP:80", listener.String(); got != expected { t.Errorf("expected %s, got %s", expected, got) } } func TestListenersString(t *testing.T) { listeners := Listeners{ Listener{ Port: 80, Protocol: "HTTP", }, Listener{ Port: 443, Protocol: "HTTPS", }, } if expected, got := "HTTP:80, HTTPS:443", listeners.String(); got != expected { t.Errorf("expected %s, got %s", expected, got) } } func TestCreateListenerParametersSetCertificateARNs(t *testing.T) { certificateARNs := []string{"arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012"} params := CreateListenerParameters{} params.SetCertificateARNs(certificateARNs) if !reflect.DeepEqual(params.CertificateARNs, certificateARNs) { t.Errorf("expected %v, got %v", certificateARNs, params.CertificateARNs) } } func TestDescribeListeners(t *testing.T) { listenerARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2" certificateARN := "arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012" resp := &awselbv2.DescribeListenersOutput{ Listeners: []*awselbv2.Listener{ &awselbv2.Listener{ ListenerArn: aws.String(listenerARN), Port: aws.Int64(80), Protocol: aws.String("HTTP"), Certificates: []*awselbv2.Certificate{ &awselbv2.Certificate{ CertificateArn: aws.String(certificateARN), }, }, }, }, } mockClient := sdk.MockDescribeListenersClient{Resp: resp} elbv2 := SDKClient{client: mockClient} listeners, err := elbv2.DescribeListeners("lbARN") if err != nil { t.Errorf("expected no error, got %v", err) } if len(listeners) != 1 { t.Errorf("expected 1 listener, got %d", len(listeners)) } if listeners[0].ARN != listenerARN { t.Errorf("expected ARN %s, got %s", listenerARN, listeners[0].ARN) } if expected := int64(80); expected != listeners[0].Port { t.Errorf("expected Port %d, got %d", expected, listeners[0].Port) } if expected := "HTTP"; expected != listeners[0].Protocol { t.Errorf("expected Port %s, got %s", expected, listeners[0].Protocol) } if listeners[0].CertificateARNs[0] != certificateARN { t.Errorf("expected certificate ARN %s, got %s", certificateARN, listeners[0].CertificateARNs[0]) } } func TestCreateListeners(t *testing.T) { lbARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188" port := int64(443) protocol := "HTTPS" defaultTargetGroupARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067" listenerARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2" certificateARNs := []string{"arn:aws:acm:us-east-1:123456789012:certificate/12345678-1234-1234-1234-123456789012"} mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2API := sdk.NewMockELBV2API(mockCtrl) elbv2 := SDKClient{client: mockELBV2API} i := &awselbv2.CreateListenerInput{ Port: aws.Int64(port), Protocol: aws.String(protocol), LoadBalancerArn: aws.String(lbARN), Certificates: []*awselbv2.Certificate{ &awselbv2.Certificate{ CertificateArn: aws.String(certificateARNs[0]), }, }, DefaultActions: []*awselbv2.Action{ &awselbv2.Action{ TargetGroupArn: aws.String(defaultTargetGroupARN), Type: aws.String("forward"), }, }, } o := &awselbv2.CreateListenerOutput{ Listeners: []*awselbv2.Listener{ &awselbv2.Listener{ ListenerArn: aws.String(listenerARN), }, }, } params := CreateListenerParameters{ CertificateARNs: certificateARNs, Port: port, Protocol: protocol, LoadBalancerARN: lbARN, DefaultTargetGroupARN: defaultTargetGroupARN, } mockELBV2API.EXPECT().CreateListener(i).Return(o, nil) arn, err := elbv2.CreateListener(params) if err != nil { t.Fatalf("expected no error, got %v", err) } if arn != listenerARN { t.Errorf("expected ARN %s, got %s", lbARN, arn) } } ================================================ FILE: elbv2/load_balancer.go ================================================ package elbv2 import ( "fmt" "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/awslabs/fargatecli/console" ) // LoadBalancer represents an Elastic Load Balancing (v2) load balancer. type LoadBalancer struct { ARN string DNSName string HostedZoneID string Listeners Listeners Name string SecurityGroupIDs []string Status string SubnetIDs []string Type string VPCID string } // LoadBalancers is a collection of Elastic Load Balancing (v2) load balancers. type LoadBalancers []LoadBalancer // CreateLoadBalancerParameters are the parameters required to create a new load balancer. type CreateLoadBalancerParameters struct { Name string SecurityGroupIDs []string SubnetIDs []string Type string Scheme string } // CreateLoadBalancer creates a new load balancer. It returns the ARN of the load balancer if it is successfully // created. func (elbv2 SDKClient) CreateLoadBalancer(p CreateLoadBalancerParameters) (string, error) { sdki := &awselbv2.CreateLoadBalancerInput{ Name: aws.String(p.Name), Subnets: aws.StringSlice(p.SubnetIDs), Type: aws.String(p.Type), Scheme: aws.String(p.Scheme), } if p.Type == awselbv2.LoadBalancerTypeEnumApplication { sdki.SetSecurityGroups(aws.StringSlice(p.SecurityGroupIDs)) } resp, err := elbv2.client.CreateLoadBalancer(sdki) if err != nil { return "", err } return aws.StringValue(resp.LoadBalancers[0].LoadBalancerArn), nil } // DescribeLoadBalancers returns all load balancers. func (elbv2 SDKClient) DescribeLoadBalancers() (LoadBalancers, error) { return elbv2.describeLoadBalancers(&awselbv2.DescribeLoadBalancersInput{}) } // DescribeLoadBalancersByName returns load balancers that match the given load balancer names. func (elbv2 SDKClient) DescribeLoadBalancersByName(lbNames []string) (LoadBalancers, error) { return elbv2.describeLoadBalancers( &awselbv2.DescribeLoadBalancersInput{Names: aws.StringSlice(lbNames)}, ) } // DescribeLoadBalancersByARN returns load balancers that match the given load balancer ARNs. func (elbv2 SDKClient) DescribeLoadBalancersByARN(lbARNs []string) (LoadBalancers, error) { return elbv2.describeLoadBalancers( &awselbv2.DescribeLoadBalancersInput{LoadBalancerArns: aws.StringSlice(lbARNs)}, ) } func (elbv2 SDKClient) DescribeLoadBalancer(lbName string) LoadBalancer { loadBalancers, _ := elbv2.DescribeLoadBalancersByName([]string{lbName}) if len(loadBalancers) == 0 { console.ErrorExit(fmt.Errorf("%s not found", lbName), "Could not find ELB load balancer") } return loadBalancers[0] } func (elbv2 SDKClient) DescribeLoadBalancerByARN(lbARN string) LoadBalancer { loadBalancers, _ := elbv2.DescribeLoadBalancersByARN([]string{lbARN}) if len(loadBalancers) == 0 { console.ErrorExit(fmt.Errorf("%s not found", lbARN), "Could not find ELB load balancer") } return loadBalancers[0] } func (elbv2 SDKClient) DeleteLoadBalancer(lbName string) { loadBalancer := elbv2.DescribeLoadBalancer(lbName) _, err := elbv2.client.DeleteLoadBalancer( &awselbv2.DeleteLoadBalancerInput{ LoadBalancerArn: aws.String(loadBalancer.ARN), }, ) if err != nil { console.ErrorExit(err, "Could not destroy ELB load balancer") } } func (elbv2 SDKClient) describeLoadBalancers(i *awselbv2.DescribeLoadBalancersInput) (LoadBalancers, error) { var loadBalancers []LoadBalancer handler := func(resp *awselbv2.DescribeLoadBalancersOutput, lastPage bool) bool { for _, loadBalancer := range resp.LoadBalancers { var subnetIDs []string for _, availabilityZone := range loadBalancer.AvailabilityZones { subnetIDs = append(subnetIDs, aws.StringValue(availabilityZone.SubnetId)) } loadBalancers = append(loadBalancers, LoadBalancer{ ARN: aws.StringValue(loadBalancer.LoadBalancerArn), DNSName: aws.StringValue(loadBalancer.DNSName), HostedZoneID: aws.StringValue(loadBalancer.CanonicalHostedZoneId), VPCID: aws.StringValue(loadBalancer.VpcId), Name: aws.StringValue(loadBalancer.LoadBalancerName), SecurityGroupIDs: aws.StringValueSlice(loadBalancer.SecurityGroups), Status: aws.StringValue(loadBalancer.State.Code), SubnetIDs: subnetIDs, Type: aws.StringValue(loadBalancer.Type), }, ) } return true } err := elbv2.client.DescribeLoadBalancersPages(i, handler) return loadBalancers, err } ================================================ FILE: elbv2/load_balancer_test.go ================================================ package elbv2 import ( "errors" "testing" "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/elbv2/mock/sdk" ) var ( lbARN = "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188" dnsName = "my-load-balancer-424835706.us-west-2.elb.amazonaws.com" hostedZoneID = "Z2P70J7EXAMPLE" vpcID = "vpc-3ac0fb5f" lbName = "web" subnet = "subnet-8360a9e7" lbType = "application" status = "active" resp = &awselbv2.DescribeLoadBalancersOutput{ LoadBalancers: []*awselbv2.LoadBalancer{ &awselbv2.LoadBalancer{ LoadBalancerArn: aws.String(lbARN), DNSName: aws.String(dnsName), CanonicalHostedZoneId: aws.String(hostedZoneID), VpcId: aws.String(vpcID), LoadBalancerName: aws.String(lbName), SecurityGroups: []*string{aws.String("sg-5943793c")}, AvailabilityZones: []*awselbv2.AvailabilityZone{ &awselbv2.AvailabilityZone{ SubnetId: aws.String(subnet), }, }, Type: aws.String(lbType), State: &awselbv2.LoadBalancerState{ Code: aws.String(status), }, }, }, } ) func TestDescribeLoadBalancers(t *testing.T) { mockClient := sdk.MockDescribeLoadBalancersClient{Resp: resp} elbv2 := SDKClient{client: mockClient} loadBalancers, err := elbv2.DescribeLoadBalancers() if err != nil { t.Errorf("expected no error, got %+v", err) } if len(loadBalancers) != 1 { t.Errorf("expected 1 load balancer, got %d", len(loadBalancers)) } if loadBalancers[0].ARN != lbARN { t.Errorf("expected ARN %s, got %s", lbARN, loadBalancers[0].ARN) } if loadBalancers[0].DNSName != dnsName { t.Errorf("expected DNSName %s, got %s", dnsName, loadBalancers[0].DNSName) } if loadBalancers[0].HostedZoneID != hostedZoneID { t.Errorf("expected HostedZoneID %s, got %s", hostedZoneID, loadBalancers[0].HostedZoneID) } if loadBalancers[0].VPCID != vpcID { t.Errorf("expected VPCID %s, got %s", vpcID, loadBalancers[0].VPCID) } if loadBalancers[0].Name != lbName { t.Errorf("expected Name %s, got %s", lbName, loadBalancers[0].Name) } if loadBalancers[0].SubnetIDs[0] != subnet { t.Errorf("expected subnet %s, got %s", subnet, loadBalancers[0].SubnetIDs[0]) } if loadBalancers[0].Type != lbType { t.Errorf("expected type %s, got %s", lbType, loadBalancers[0].Type) } if loadBalancers[0].Status != status { t.Errorf("expected status %s, got %s", status, loadBalancers[0].Status) } } func TestDescribeLoadBalancersByName(t *testing.T) { mockClient := sdk.MockDescribeLoadBalancersClient{Resp: resp} elbv2 := SDKClient{client: mockClient} loadBalancers, err := elbv2.DescribeLoadBalancersByName([]string{"web"}) if err != nil { t.Errorf("Expected no error, got %+v", err) } if len(loadBalancers) != 1 { t.Errorf("Expected 1 load balancer, got %d", len(loadBalancers)) } } func TestDescribeLoadBalancersByARN(t *testing.T) { mockClient := sdk.MockDescribeLoadBalancersClient{Resp: resp} elbv2 := SDKClient{client: mockClient} loadBalancers, err := elbv2.DescribeLoadBalancersByARN([]string{lbARN}) if err != nil { t.Errorf("Expected no error, got %+v", err) } if len(loadBalancers) != 1 { t.Errorf("Expected 1 load balancer, got %d", len(loadBalancers)) } } func TestDescribeLoadBalancersByNameError(t *testing.T) { mockClient := sdk.MockDescribeLoadBalancersClient{Error: errors.New("boom")} elbv2 := SDKClient{client: mockClient} _, err := elbv2.DescribeLoadBalancersByName([]string{"web"}) if err == nil { t.Error("Expected error, got none") } } func TestCreateLoadBalancer(t *testing.T) { lbARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188" name := "cool-load-balancer" subnetIDs := []string{"subnet-1234567"} securityGroupIDs := []string{"sg-1234567"} lbType := "application" lbScheme := "internet-facing" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2API := sdk.NewMockELBV2API(mockCtrl) elbv2 := SDKClient{client: mockELBV2API} i := &awselbv2.CreateLoadBalancerInput{ Name: aws.String(name), Subnets: aws.StringSlice(subnetIDs), SecurityGroups: aws.StringSlice(securityGroupIDs), Type: aws.String(lbType), Scheme: aws.String(lbScheme), } o := &awselbv2.CreateLoadBalancerOutput{ LoadBalancers: []*awselbv2.LoadBalancer{ &awselbv2.LoadBalancer{ LoadBalancerArn: aws.String(lbARN), }, }, } params := CreateLoadBalancerParameters{ Name: name, SubnetIDs: subnetIDs, Type: lbType, Scheme: lbScheme, SecurityGroupIDs: securityGroupIDs, } mockELBV2API.EXPECT().CreateLoadBalancer(i).Return(o, nil) arn, err := elbv2.CreateLoadBalancer(params) if err != nil { t.Fatalf("expected no error, got %v", err) } if arn != lbARN { t.Errorf("expected ARN %s, got %s", lbARN, arn) } } func TestCreateLoadBalancerWithError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2API := sdk.NewMockELBV2API(mockCtrl) elbv2 := SDKClient{client: mockELBV2API} mockELBV2API.EXPECT().CreateLoadBalancer(gomock.Any()).Return(nil, errors.New("boom")) _, err := elbv2.CreateLoadBalancer(CreateLoadBalancerParameters{}) if err == nil { t.Fatalf("expected error, got none") } } ================================================ FILE: elbv2/main.go ================================================ // Package elbv2 is a client for Elastic Load Balancing (v2). package elbv2 //go:generate mockgen -package client -destination=mock/client/client.go github.com/awslabs/fargatecli/elbv2 Client //go:generate mockgen -package sdk -source ../vendor/github.com/aws/aws-sdk-go/service/elbv2/elbv2iface/interface.go -destination=mock/sdk/elbv2iface.go github.com/aws/aws-sdk-go/service/elbv2/elbv2iface ELBV2API import ( "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" ) // Client represents a method for accessing Elastic Load Balancing (v2). type Client interface { CreateListener(CreateListenerParameters) (string, error) DescribeListeners(string) (Listeners, error) DescribeLoadBalancers() (LoadBalancers, error) DescribeLoadBalancersByName([]string) (LoadBalancers, error) CreateLoadBalancer(CreateLoadBalancerParameters) (string, error) CreateTargetGroup(CreateTargetGroupParameters) (string, error) } // SDKClient implements access to Elastic Load Balancing (v2) via the AWS SDK. type SDKClient struct { client elbv2iface.ELBV2API } // New returns an SDKClient configured with the given session. func New(sess *session.Session) SDKClient { return SDKClient{ client: elbv2.New(sess), } } ================================================ FILE: elbv2/mock/client/client.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/awslabs/fargatecli/elbv2 (interfaces: Client) // Package client is a generated GoMock package. package client import ( elbv2 "github.com/awslabs/fargatecli/elbv2" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } // MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } // NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } // CreateListener mocks base method func (m *MockClient) CreateListener(arg0 elbv2.CreateListenerParameters) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateListener", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateListener indicates an expected call of CreateListener func (mr *MockClientMockRecorder) CreateListener(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockClient)(nil).CreateListener), arg0) } // CreateLoadBalancer mocks base method func (m *MockClient) CreateLoadBalancer(arg0 elbv2.CreateLoadBalancerParameters) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateLoadBalancer", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateLoadBalancer indicates an expected call of CreateLoadBalancer func (mr *MockClientMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockClient)(nil).CreateLoadBalancer), arg0) } // CreateTargetGroup mocks base method func (m *MockClient) CreateTargetGroup(arg0 elbv2.CreateTargetGroupParameters) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTargetGroup", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTargetGroup indicates an expected call of CreateTargetGroup func (mr *MockClientMockRecorder) CreateTargetGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockClient)(nil).CreateTargetGroup), arg0) } // DescribeListeners mocks base method func (m *MockClient) DescribeListeners(arg0 string) (elbv2.Listeners, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeListeners", arg0) ret0, _ := ret[0].(elbv2.Listeners) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeListeners indicates an expected call of DescribeListeners func (mr *MockClientMockRecorder) DescribeListeners(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockClient)(nil).DescribeListeners), arg0) } // DescribeLoadBalancers mocks base method func (m *MockClient) DescribeLoadBalancers() (elbv2.LoadBalancers, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeLoadBalancers") ret0, _ := ret[0].(elbv2.LoadBalancers) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers func (mr *MockClientMockRecorder) DescribeLoadBalancers() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancers)) } // DescribeLoadBalancersByName mocks base method func (m *MockClient) DescribeLoadBalancersByName(arg0 []string) (elbv2.LoadBalancers, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeLoadBalancersByName", arg0) ret0, _ := ret[0].(elbv2.LoadBalancers) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeLoadBalancersByName indicates an expected call of DescribeLoadBalancersByName func (mr *MockClientMockRecorder) DescribeLoadBalancersByName(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersByName", reflect.TypeOf((*MockClient)(nil).DescribeLoadBalancersByName), arg0) } ================================================ FILE: elbv2/mock/sdk/elbv2iface.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: ../vendor/github.com/aws/aws-sdk-go/service/elbv2/elbv2iface/interface.go // Package sdk is a generated GoMock package. package sdk import ( aws "github.com/aws/aws-sdk-go/aws" request "github.com/aws/aws-sdk-go/aws/request" elbv2 "github.com/aws/aws-sdk-go/service/elbv2" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockELBV2API is a mock of ELBV2API interface type MockELBV2API struct { ctrl *gomock.Controller recorder *MockELBV2APIMockRecorder } // MockELBV2APIMockRecorder is the mock recorder for MockELBV2API type MockELBV2APIMockRecorder struct { mock *MockELBV2API } // NewMockELBV2API creates a new mock instance func NewMockELBV2API(ctrl *gomock.Controller) *MockELBV2API { mock := &MockELBV2API{ctrl: ctrl} mock.recorder = &MockELBV2APIMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockELBV2API) EXPECT() *MockELBV2APIMockRecorder { return m.recorder } // AddListenerCertificates mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) AddListenerCertificates(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificates), arg0) } // AddListenerCertificatesWithContext mocks base method func (m *MockELBV2API) AddListenerCertificatesWithContext(arg0 aws.Context, arg1 *elbv2.AddListenerCertificatesInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // AddListenerCertificatesWithContext indicates an expected call of AddListenerCertificatesWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).AddListenerCertificatesWithContext), varargs...) } // AddListenerCertificatesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) AddListenerCertificatesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).AddListenerCertificatesRequest), arg0) } // AddTags mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) AddTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTags", reflect.TypeOf((*MockELBV2API)(nil).AddTags), arg0) } // AddTagsWithContext mocks base method func (m *MockELBV2API) AddTagsWithContext(arg0 aws.Context, arg1 *elbv2.AddTagsInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // AddTagsWithContext indicates an expected call of AddTagsWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).AddTagsWithContext), varargs...) } // AddTagsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) AddTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).AddTagsRequest), arg0) } // CreateListener mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateListener(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListener", reflect.TypeOf((*MockELBV2API)(nil).CreateListener), arg0) } // CreateListenerWithContext mocks base method func (m *MockELBV2API) CreateListenerWithContext(arg0 aws.Context, arg1 *elbv2.CreateListenerInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateListenerWithContext indicates an expected call of CreateListenerWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).CreateListenerWithContext), varargs...) } // CreateListenerRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateListenerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateListenerRequest), arg0) } // CreateLoadBalancer mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateLoadBalancer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancer), arg0) } // CreateLoadBalancerWithContext mocks base method func (m *MockELBV2API) CreateLoadBalancerWithContext(arg0 aws.Context, arg1 *elbv2.CreateLoadBalancerInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateLoadBalancerWithContext indicates an expected call of CreateLoadBalancerWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).CreateLoadBalancerWithContext), varargs...) } // CreateLoadBalancerRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateLoadBalancerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateLoadBalancerRequest), arg0) } // CreateRule mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRule", reflect.TypeOf((*MockELBV2API)(nil).CreateRule), arg0) } // CreateRuleWithContext mocks base method func (m *MockELBV2API) CreateRuleWithContext(arg0 aws.Context, arg1 *elbv2.CreateRuleInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateRuleWithContext indicates an expected call of CreateRuleWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).CreateRuleWithContext), varargs...) } // CreateRuleRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateRuleRequest), arg0) } // CreateTargetGroup mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateTargetGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroup), arg0) } // CreateTargetGroupWithContext mocks base method func (m *MockELBV2API) CreateTargetGroupWithContext(arg0 aws.Context, arg1 *elbv2.CreateTargetGroupInput, arg2 ...request.Option) (*elbv2.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) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTargetGroupWithContext indicates an expected call of CreateTargetGroupWithContext func (mr *MockELBV2APIMockRecorder) CreateTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupWithContext), varargs...) } // CreateTargetGroupRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) CreateTargetGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).CreateTargetGroupRequest), arg0) } // DeleteListener mocks base method func (m *MockELBV2API) DeleteListener(arg0 *elbv2.DeleteListenerInput) (*elbv2.DeleteListenerOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteListener", arg0) ret0, _ := ret[0].(*elbv2.DeleteListenerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteListener indicates an expected call of DeleteListener func (mr *MockELBV2APIMockRecorder) DeleteListener(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListener", reflect.TypeOf((*MockELBV2API)(nil).DeleteListener), arg0) } // DeleteListenerWithContext mocks base method func (m *MockELBV2API) DeleteListenerWithContext(arg0 aws.Context, arg1 *elbv2.DeleteListenerInput, arg2 ...request.Option) (*elbv2.DeleteListenerOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteListenerWithContext indicates an expected call of DeleteListenerWithContext func (mr *MockELBV2APIMockRecorder) DeleteListenerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerWithContext), varargs...) } // DeleteListenerRequest mocks base method func (m *MockELBV2API) DeleteListenerRequest(arg0 *elbv2.DeleteListenerInput) (*request.Request, *elbv2.DeleteListenerOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteListenerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DeleteListenerOutput) return ret0, ret1 } // DeleteListenerRequest indicates an expected call of DeleteListenerRequest func (mr *MockELBV2APIMockRecorder) DeleteListenerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteListenerRequest), arg0) } // DeleteLoadBalancer mocks base method func (m *MockELBV2API) DeleteLoadBalancer(arg0 *elbv2.DeleteLoadBalancerInput) (*elbv2.DeleteLoadBalancerOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteLoadBalancer", arg0) ret0, _ := ret[0].(*elbv2.DeleteLoadBalancerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteLoadBalancer indicates an expected call of DeleteLoadBalancer func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancer", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancer), arg0) } // DeleteLoadBalancerWithContext mocks base method func (m *MockELBV2API) DeleteLoadBalancerWithContext(arg0 aws.Context, arg1 *elbv2.DeleteLoadBalancerInput, arg2 ...request.Option) (*elbv2.DeleteLoadBalancerOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteLoadBalancerWithContext indicates an expected call of DeleteLoadBalancerWithContext func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerWithContext), varargs...) } // DeleteLoadBalancerRequest mocks base method func (m *MockELBV2API) DeleteLoadBalancerRequest(arg0 *elbv2.DeleteLoadBalancerInput) (*request.Request, *elbv2.DeleteLoadBalancerOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteLoadBalancerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DeleteLoadBalancerOutput) return ret0, ret1 } // DeleteLoadBalancerRequest indicates an expected call of DeleteLoadBalancerRequest func (mr *MockELBV2APIMockRecorder) DeleteLoadBalancerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLoadBalancerRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteLoadBalancerRequest), arg0) } // DeleteRule mocks base method func (m *MockELBV2API) DeleteRule(arg0 *elbv2.DeleteRuleInput) (*elbv2.DeleteRuleOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteRule", arg0) ret0, _ := ret[0].(*elbv2.DeleteRuleOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteRule indicates an expected call of DeleteRule func (mr *MockELBV2APIMockRecorder) DeleteRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRule", reflect.TypeOf((*MockELBV2API)(nil).DeleteRule), arg0) } // DeleteRuleWithContext mocks base method func (m *MockELBV2API) DeleteRuleWithContext(arg0 aws.Context, arg1 *elbv2.DeleteRuleInput, arg2 ...request.Option) (*elbv2.DeleteRuleOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteRuleWithContext indicates an expected call of DeleteRuleWithContext func (mr *MockELBV2APIMockRecorder) DeleteRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleWithContext), varargs...) } // DeleteRuleRequest mocks base method func (m *MockELBV2API) DeleteRuleRequest(arg0 *elbv2.DeleteRuleInput) (*request.Request, *elbv2.DeleteRuleOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteRuleRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DeleteRuleOutput) return ret0, ret1 } // DeleteRuleRequest indicates an expected call of DeleteRuleRequest func (mr *MockELBV2APIMockRecorder) DeleteRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteRuleRequest), arg0) } // DeleteTargetGroup mocks base method func (m *MockELBV2API) DeleteTargetGroup(arg0 *elbv2.DeleteTargetGroupInput) (*elbv2.DeleteTargetGroupOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTargetGroup", arg0) ret0, _ := ret[0].(*elbv2.DeleteTargetGroupOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTargetGroup indicates an expected call of DeleteTargetGroup func (mr *MockELBV2APIMockRecorder) DeleteTargetGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroup), arg0) } // DeleteTargetGroupWithContext mocks base method func (m *MockELBV2API) DeleteTargetGroupWithContext(arg0 aws.Context, arg1 *elbv2.DeleteTargetGroupInput, arg2 ...request.Option) (*elbv2.DeleteTargetGroupOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTargetGroupWithContext indicates an expected call of DeleteTargetGroupWithContext func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupWithContext), varargs...) } // DeleteTargetGroupRequest mocks base method func (m *MockELBV2API) DeleteTargetGroupRequest(arg0 *elbv2.DeleteTargetGroupInput) (*request.Request, *elbv2.DeleteTargetGroupOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTargetGroupRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DeleteTargetGroupOutput) return ret0, ret1 } // DeleteTargetGroupRequest indicates an expected call of DeleteTargetGroupRequest func (mr *MockELBV2APIMockRecorder) DeleteTargetGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).DeleteTargetGroupRequest), arg0) } // DeregisterTargets mocks base method func (m *MockELBV2API) DeregisterTargets(arg0 *elbv2.DeregisterTargetsInput) (*elbv2.DeregisterTargetsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeregisterTargets", arg0) ret0, _ := ret[0].(*elbv2.DeregisterTargetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeregisterTargets indicates an expected call of DeregisterTargets func (mr *MockELBV2APIMockRecorder) DeregisterTargets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargets", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargets), arg0) } // DeregisterTargetsWithContext mocks base method func (m *MockELBV2API) DeregisterTargetsWithContext(arg0 aws.Context, arg1 *elbv2.DeregisterTargetsInput, arg2 ...request.Option) (*elbv2.DeregisterTargetsOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DeregisterTargetsWithContext indicates an expected call of DeregisterTargetsWithContext func (mr *MockELBV2APIMockRecorder) DeregisterTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsWithContext), varargs...) } // DeregisterTargetsRequest mocks base method func (m *MockELBV2API) DeregisterTargetsRequest(arg0 *elbv2.DeregisterTargetsInput) (*request.Request, *elbv2.DeregisterTargetsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeregisterTargetsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DeregisterTargetsOutput) return ret0, ret1 } // DeregisterTargetsRequest indicates an expected call of DeregisterTargetsRequest func (mr *MockELBV2APIMockRecorder) DeregisterTargetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).DeregisterTargetsRequest), arg0) } // DescribeAccountLimits mocks base method func (m *MockELBV2API) DescribeAccountLimits(arg0 *elbv2.DescribeAccountLimitsInput) (*elbv2.DescribeAccountLimitsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) ret0, _ := ret[0].(*elbv2.DescribeAccountLimitsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeAccountLimits indicates an expected call of DescribeAccountLimits func (mr *MockELBV2APIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimits), arg0) } // DescribeAccountLimitsWithContext mocks base method func (m *MockELBV2API) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *elbv2.DescribeAccountLimitsInput, arg2 ...request.Option) (*elbv2.DescribeAccountLimitsOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext func (mr *MockELBV2APIMockRecorder) DescribeAccountLimitsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimitsWithContext), varargs...) } // DescribeAccountLimitsRequest mocks base method func (m *MockELBV2API) DescribeAccountLimitsRequest(arg0 *elbv2.DescribeAccountLimitsInput) (*request.Request, *elbv2.DescribeAccountLimitsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DescribeAccountLimitsOutput) return ret0, ret1 } // DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest func (mr *MockELBV2APIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeAccountLimitsRequest), arg0) } // DescribeListenerCertificates mocks base method func (m *MockELBV2API) DescribeListenerCertificates(arg0 *elbv2.DescribeListenerCertificatesInput) (*elbv2.DescribeListenerCertificatesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeListenerCertificates", arg0) ret0, _ := ret[0].(*elbv2.DescribeListenerCertificatesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeListenerCertificates indicates an expected call of DescribeListenerCertificates func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificates(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificates), arg0) } // DescribeListenerCertificatesWithContext mocks base method func (m *MockELBV2API) DescribeListenerCertificatesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeListenerCertificatesInput, arg2 ...request.Option) (*elbv2.DescribeListenerCertificatesOutput, 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) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeListenerCertificatesWithContext indicates an expected call of DescribeListenerCertificatesWithContext func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesWithContext", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesWithContext), varargs...) } // DescribeListenerCertificatesRequest mocks base method func (m *MockELBV2API) DescribeListenerCertificatesRequest(arg0 *elbv2.DescribeListenerCertificatesInput) (*request.Request, *elbv2.DescribeListenerCertificatesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeListenerCertificatesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*elbv2.DescribeListenerCertificatesOutput) return ret0, ret1 } // DescribeListenerCertificatesRequest indicates an expected call of DescribeListenerCertificatesRequest func (mr *MockELBV2APIMockRecorder) DescribeListenerCertificatesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenerCertificatesRequest), arg0) } // DescribeListeners mocks base method func (m *MockELBV2API) DescribeListeners(arg0 *elbv2.DescribeListenersInput) (*elbv2.DescribeListenersOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DescribeListeners", arg0) ret0, _ := ret[0].(*elbv2.DescribeListenersOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DescribeListeners indicates an expected call of DescribeListeners func (mr *MockELBV2APIMockRecorder) DescribeListeners(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListeners", reflect.TypeOf((*MockELBV2API)(nil).DescribeListeners), arg0) } // DescribeListenersWithContext mocks base method func (m *MockELBV2API) DescribeListenersWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeListenersWithContext), varargs...) } // DescribeListenersRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeListenersRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersRequest), arg0) } // DescribeListenersPages mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeListenersPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeListenersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeListenersPages), arg0, arg1) } // DescribeListenersPagesWithContext mocks base method func (m *MockELBV2API) DescribeListenersPagesWithContext(arg0 aws.Context, arg1 *elbv2.DescribeListenersInput, arg2 func(*elbv2.DescribeListenersOutput, 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, "DescribeListenersPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // DescribeListenersPagesWithContext indicates an expected call of DescribeListenersPagesWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeListenersPagesWithContext), varargs...) } // DescribeLoadBalancerAttributes mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributes), arg0) } // DescribeLoadBalancerAttributesWithContext mocks base method func (m *MockELBV2API) DescribeLoadBalancerAttributesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeLoadBalancerAttributesWithContext), varargs...) } // DescribeLoadBalancerAttributesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancerAttributesRequest), arg0) } // DescribeLoadBalancers mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancers), arg0) } // DescribeLoadBalancersWithContext mocks base method func (m *MockELBV2API) DescribeLoadBalancersWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeLoadBalancersWithContext), varargs...) } // DescribeLoadBalancersRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersRequest), arg0) } // DescribeLoadBalancersPages mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeLoadBalancersPages), arg0, arg1) } // DescribeLoadBalancersPagesWithContext mocks base method func (m *MockELBV2API) DescribeLoadBalancersPagesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeLoadBalancersPagesWithContext), varargs...) } // DescribeRules mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeRules(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRules", reflect.TypeOf((*MockELBV2API)(nil).DescribeRules), arg0) } // DescribeRulesWithContext mocks base method func (m *MockELBV2API) DescribeRulesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeRulesWithContext), varargs...) } // DescribeRulesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeRulesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRulesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeRulesRequest), arg0) } // DescribeSSLPolicies mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeSSLPolicies(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPolicies", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPolicies), arg0) } // DescribeSSLPoliciesWithContext mocks base method func (m *MockELBV2API) DescribeSSLPoliciesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeSSLPoliciesWithContext), varargs...) } // DescribeSSLPoliciesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeSSLPoliciesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSSLPoliciesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeSSLPoliciesRequest), arg0) } // DescribeTags mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockELBV2API)(nil).DescribeTags), arg0) } // DescribeTagsWithContext mocks base method func (m *MockELBV2API) DescribeTagsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTagsWithContext), varargs...) } // DescribeTagsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTagsRequest), arg0) } // DescribeTargetGroupAttributes mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetGroupAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributes), arg0) } // DescribeTargetGroupAttributesWithContext mocks base method func (m *MockELBV2API) DescribeTargetGroupAttributesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTargetGroupAttributesWithContext), varargs...) } // DescribeTargetGroupAttributesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupAttributesRequest), arg0) } // DescribeTargetGroups mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroups", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroups), arg0) } // DescribeTargetGroupsWithContext mocks base method func (m *MockELBV2API) DescribeTargetGroupsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTargetGroupsWithContext), varargs...) } // DescribeTargetGroupsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsRequest), arg0) } // DescribeTargetGroupsPages mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetGroupsPages", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetGroupsPages), arg0, arg1) } // DescribeTargetGroupsPagesWithContext mocks base method func (m *MockELBV2API) DescribeTargetGroupsPagesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTargetGroupsPagesWithContext), varargs...) } // DescribeTargetHealth mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetHealth(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealth", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealth), arg0) } // DescribeTargetHealthWithContext mocks base method func (m *MockELBV2API) DescribeTargetHealthWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).DescribeTargetHealthWithContext), varargs...) } // DescribeTargetHealthRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) DescribeTargetHealthRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTargetHealthRequest", reflect.TypeOf((*MockELBV2API)(nil).DescribeTargetHealthRequest), arg0) } // ModifyListener mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyListener(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListener", reflect.TypeOf((*MockELBV2API)(nil).ModifyListener), arg0) } // ModifyListenerWithContext mocks base method func (m *MockELBV2API) ModifyListenerWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).ModifyListenerWithContext), varargs...) } // ModifyListenerRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyListenerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyListenerRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyListenerRequest), arg0) } // ModifyLoadBalancerAttributes mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributes), arg0) } // ModifyLoadBalancerAttributesWithContext mocks base method func (m *MockELBV2API) ModifyLoadBalancerAttributesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).ModifyLoadBalancerAttributesWithContext), varargs...) } // ModifyLoadBalancerAttributesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyLoadBalancerAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLoadBalancerAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyLoadBalancerAttributesRequest), arg0) } // ModifyRule mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyRule(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRule", reflect.TypeOf((*MockELBV2API)(nil).ModifyRule), arg0) } // ModifyRuleWithContext mocks base method func (m *MockELBV2API) ModifyRuleWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).ModifyRuleWithContext), varargs...) } // ModifyRuleRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyRuleRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyRuleRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyRuleRequest), arg0) } // ModifyTargetGroup mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyTargetGroup(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroup", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroup), arg0) } // ModifyTargetGroupWithContext mocks base method func (m *MockELBV2API) ModifyTargetGroupWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).ModifyTargetGroupWithContext), varargs...) } // ModifyTargetGroupRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyTargetGroupRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupRequest), arg0) } // ModifyTargetGroupAttributes mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyTargetGroupAttributes(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributes", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributes), arg0) } // ModifyTargetGroupAttributesWithContext mocks base method func (m *MockELBV2API) ModifyTargetGroupAttributesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).ModifyTargetGroupAttributesWithContext), varargs...) } // ModifyTargetGroupAttributesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) ModifyTargetGroupAttributesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTargetGroupAttributesRequest", reflect.TypeOf((*MockELBV2API)(nil).ModifyTargetGroupAttributesRequest), arg0) } // RegisterTargets mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RegisterTargets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargets", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargets), arg0) } // RegisterTargetsWithContext mocks base method func (m *MockELBV2API) RegisterTargetsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).RegisterTargetsWithContext), varargs...) } // RegisterTargetsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RegisterTargetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterTargetsRequest", reflect.TypeOf((*MockELBV2API)(nil).RegisterTargetsRequest), arg0) } // RemoveListenerCertificates mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RemoveListenerCertificates(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificates", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificates), arg0) } // RemoveListenerCertificatesWithContext mocks base method func (m *MockELBV2API) RemoveListenerCertificatesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).RemoveListenerCertificatesWithContext), varargs...) } // RemoveListenerCertificatesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RemoveListenerCertificatesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveListenerCertificatesRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveListenerCertificatesRequest), arg0) } // RemoveTags mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RemoveTags(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTags", reflect.TypeOf((*MockELBV2API)(nil).RemoveTags), arg0) } // RemoveTagsWithContext mocks base method func (m *MockELBV2API) RemoveTagsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).RemoveTagsWithContext), varargs...) } // RemoveTagsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) RemoveTagsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveTagsRequest", reflect.TypeOf((*MockELBV2API)(nil).RemoveTagsRequest), arg0) } // SetIpAddressType mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetIpAddressType(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressType", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressType), arg0) } // SetIpAddressTypeWithContext mocks base method func (m *MockELBV2API) SetIpAddressTypeWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).SetIpAddressTypeWithContext), varargs...) } // SetIpAddressTypeRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetIpAddressTypeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIpAddressTypeRequest", reflect.TypeOf((*MockELBV2API)(nil).SetIpAddressTypeRequest), arg0) } // SetRulePriorities mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetRulePriorities(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePriorities", reflect.TypeOf((*MockELBV2API)(nil).SetRulePriorities), arg0) } // SetRulePrioritiesWithContext mocks base method func (m *MockELBV2API) SetRulePrioritiesWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).SetRulePrioritiesWithContext), varargs...) } // SetRulePrioritiesRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetRulePrioritiesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRulePrioritiesRequest", reflect.TypeOf((*MockELBV2API)(nil).SetRulePrioritiesRequest), arg0) } // SetSecurityGroups mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetSecurityGroups(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroups", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroups), arg0) } // SetSecurityGroupsWithContext mocks base method func (m *MockELBV2API) SetSecurityGroupsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).SetSecurityGroupsWithContext), varargs...) } // SetSecurityGroupsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetSecurityGroupsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSecurityGroupsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSecurityGroupsRequest), arg0) } // SetSubnets mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetSubnets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnets", reflect.TypeOf((*MockELBV2API)(nil).SetSubnets), arg0) } // SetSubnetsWithContext mocks base method func (m *MockELBV2API) SetSubnetsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).SetSubnetsWithContext), varargs...) } // SetSubnetsRequest mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) SetSubnetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubnetsRequest", reflect.TypeOf((*MockELBV2API)(nil).SetSubnetsRequest), arg0) } // WaitUntilLoadBalancerAvailable mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) WaitUntilLoadBalancerAvailable(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerAvailable", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailable), arg0) } // WaitUntilLoadBalancerAvailableWithContext mocks base method func (m *MockELBV2API) WaitUntilLoadBalancerAvailableWithContext(arg0 aws.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...) ret0, _ := ret[0].(error) return ret0 } // WaitUntilLoadBalancerAvailableWithContext indicates an expected call of WaitUntilLoadBalancerAvailableWithContext func (mr *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).WaitUntilLoadBalancerAvailableWithContext), varargs...) } // WaitUntilLoadBalancerExists mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) WaitUntilLoadBalancerExists(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancerExists", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancerExists), arg0) } // WaitUntilLoadBalancerExistsWithContext mocks base method func (m *MockELBV2API) WaitUntilLoadBalancerExistsWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).WaitUntilLoadBalancerExistsWithContext), varargs...) } // WaitUntilLoadBalancersDeleted mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) WaitUntilLoadBalancersDeleted(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilLoadBalancersDeleted", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilLoadBalancersDeleted), arg0) } // WaitUntilLoadBalancersDeletedWithContext mocks base method func (m *MockELBV2API) WaitUntilLoadBalancersDeletedWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).WaitUntilLoadBalancersDeletedWithContext), varargs...) } // WaitUntilTargetDeregistered mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) WaitUntilTargetDeregistered(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetDeregistered", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetDeregistered), arg0) } // WaitUntilTargetDeregisteredWithContext mocks base method func (m *MockELBV2API) WaitUntilTargetDeregisteredWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) 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((*MockELBV2API)(nil).WaitUntilTargetDeregisteredWithContext), varargs...) } // WaitUntilTargetInService mocks base method func (m *MockELBV2API) 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 *MockELBV2APIMockRecorder) WaitUntilTargetInService(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInService", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInService), arg0) } // WaitUntilTargetInServiceWithContext mocks base method func (m *MockELBV2API) WaitUntilTargetInServiceWithContext(arg0 aws.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 *MockELBV2APIMockRecorder) WaitUntilTargetInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilTargetInServiceWithContext", reflect.TypeOf((*MockELBV2API)(nil).WaitUntilTargetInServiceWithContext), varargs...) } ================================================ FILE: elbv2/mock/sdk/paginators.go ================================================ package sdk import ( "github.com/aws/aws-sdk-go/service/elbv2" "github.com/aws/aws-sdk-go/service/elbv2/elbv2iface" ) type MockDescribeLoadBalancersClient struct { elbv2iface.ELBV2API Resp *elbv2.DescribeLoadBalancersOutput Error error } type MockDescribeListenersClient struct { elbv2iface.ELBV2API Resp *elbv2.DescribeListenersOutput Error error } func (m MockDescribeLoadBalancersClient) DescribeLoadBalancersPages(in *elbv2.DescribeLoadBalancersInput, fn func(*elbv2.DescribeLoadBalancersOutput, bool) bool) error { if m.Error != nil { return m.Error } fn(m.Resp, true) return nil } func (m MockDescribeListenersClient) DescribeListenersPages(in *elbv2.DescribeListenersInput, fn func(*elbv2.DescribeListenersOutput, bool) bool) error { if m.Error != nil { return m.Error } fn(m.Resp, true) return nil } ================================================ FILE: elbv2/target_group.go ================================================ package elbv2 import ( "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/awslabs/fargatecli/console" ) type TargetGroup struct { Name string Arn string LoadBalancerARN string } type CreateTargetGroupParameters struct { Name string Port int64 Protocol string VPCID string } func (elbv2 SDKClient) CreateTargetGroup(i CreateTargetGroupParameters) (string, error) { resp, err := elbv2.client.CreateTargetGroup( &awselbv2.CreateTargetGroupInput{ Name: aws.String(i.Name), Port: aws.Int64(i.Port), Protocol: aws.String(i.Protocol), TargetType: aws.String(awselbv2.TargetTypeEnumIp), VpcId: aws.String(i.VPCID), }, ) if err != nil { return "", err } return aws.StringValue(resp.TargetGroups[0].TargetGroupArn), nil } func (elbv2 SDKClient) DeleteTargetGroup(targetGroupName string) { console.Debug("Deleting ELB target group") targetGroup := elbv2.describeTargetGroupByName(targetGroupName) elbv2.client.DeleteTargetGroup( &awselbv2.DeleteTargetGroupInput{ TargetGroupArn: targetGroup.TargetGroupArn, }, ) } func (elbv2 SDKClient) DeleteTargetGroupByArn(targetGroupARN string) { _, err := elbv2.client.DeleteTargetGroup( &awselbv2.DeleteTargetGroupInput{ TargetGroupArn: aws.String(targetGroupARN), }, ) if err != nil { console.ErrorExit(err, "Could not delete ELB target group") } } func (elbv2 SDKClient) GetTargetGroupArn(targetGroupName string) string { resp, _ := elbv2.client.DescribeTargetGroups( &awselbv2.DescribeTargetGroupsInput{ Names: aws.StringSlice([]string{targetGroupName}), }, ) if len(resp.TargetGroups) == 1 { return aws.StringValue(resp.TargetGroups[0].TargetGroupArn) } return "" } func (elbv2 SDKClient) GetTargetGroupLoadBalancerArn(targetGroupARN string) string { targetGroup := elbv2.describeTargetGroupByArn(targetGroupARN) if len(targetGroup.LoadBalancerArns) > 0 { return aws.StringValue(targetGroup.LoadBalancerArns[0]) } else { return "" } } func (elbv2 SDKClient) DescribeTargetGroups(targetGroupARNs []string) []TargetGroup { var targetGroups []TargetGroup resp, err := elbv2.client.DescribeTargetGroups( &awselbv2.DescribeTargetGroupsInput{ TargetGroupArns: aws.StringSlice(targetGroupARNs), }, ) if err != nil { console.ErrorExit(err, "Could not describe ELB target groups") } for _, targetGroup := range resp.TargetGroups { tg := TargetGroup{ Name: aws.StringValue(targetGroup.TargetGroupName), Arn: aws.StringValue(targetGroup.TargetGroupArn), } if len(targetGroup.LoadBalancerArns) > 0 { tg.LoadBalancerARN = aws.StringValue(targetGroup.LoadBalancerArns[0]) } targetGroups = append(targetGroups, tg) } return targetGroups } func (elbv2 SDKClient) describeTargetGroupByName(targetGroupName string) *awselbv2.TargetGroup { resp, err := elbv2.client.DescribeTargetGroups( &awselbv2.DescribeTargetGroupsInput{ Names: aws.StringSlice([]string{targetGroupName}), }, ) if err != nil { console.ErrorExit(err, "Could not describe ELB target groups") } if len(resp.TargetGroups) != 1 { console.IssueExit("Could not describe ELB target groups") } return resp.TargetGroups[0] } func (elbv2 SDKClient) describeTargetGroupByArn(targetGroupARN string) *awselbv2.TargetGroup { resp, err := elbv2.client.DescribeTargetGroups( &awselbv2.DescribeTargetGroupsInput{ TargetGroupArns: aws.StringSlice([]string{targetGroupARN}), }, ) if err != nil { console.ErrorExit(err, "Could not describe ELB target groups") } if len(resp.TargetGroups) != 1 { console.IssueExit("Could not describe ELB target groups") } return resp.TargetGroups[0] } ================================================ FILE: elbv2/target_group_test.go ================================================ package elbv2 import ( "errors" "testing" "github.com/aws/aws-sdk-go/aws" awselbv2 "github.com/aws/aws-sdk-go/service/elbv2" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/elbv2/mock/sdk" ) func TestCreateTargetGroup(t *testing.T) { name := "default" port := int64(80) protocol := "HTTP" vpcID := "vpc-1234567" targetGroupARN := "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2API := sdk.NewMockELBV2API(mockCtrl) elbv2 := SDKClient{client: mockELBV2API} i := &awselbv2.CreateTargetGroupInput{ Name: aws.String(name), Port: aws.Int64(port), Protocol: aws.String(protocol), TargetType: aws.String("ip"), VpcId: aws.String(vpcID), } o := &awselbv2.CreateTargetGroupOutput{ TargetGroups: []*awselbv2.TargetGroup{ &awselbv2.TargetGroup{ TargetGroupArn: aws.String(targetGroupARN), }, }, } mockELBV2API.EXPECT().CreateTargetGroup(i).Return(o, nil) arn, err := elbv2.CreateTargetGroup( CreateTargetGroupParameters{ Name: name, Port: port, Protocol: protocol, VPCID: vpcID, }, ) if err != nil { t.Fatalf("expected no error, got %v", err) } if arn == "" { t.Errorf("expected ARN %s, got %s", targetGroupARN, arn) } } func TestCreateTargetGroupError(t *testing.T) { mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockELBV2API := sdk.NewMockELBV2API(mockCtrl) elbv2 := SDKClient{client: mockELBV2API} mockELBV2API.EXPECT().CreateTargetGroup(gomock.Any()).Return(&awselbv2.CreateTargetGroupOutput{}, errors.New("boom")) arn, err := elbv2.CreateTargetGroup( CreateTargetGroupParameters{ Name: "default", Port: int64(80), Protocol: "HTTP", VPCID: "vpc-1234567", }, ) if err == nil { t.Fatalf("expected error, got none") } if arn != "" { t.Errorf("expected empty ARN, got %s", arn) } } ================================================ FILE: git/main.go ================================================ package git import ( "os" "os/exec" "strings" "github.com/awslabs/fargatecli/console" ) func GetShortSha() string { var sha string cmd := exec.Command("git", "rev-parse", "--short", "HEAD") if console.Verbose { cmd.Stderr = os.Stderr } if out, err := cmd.Output(); err == nil { sha = strings.TrimSpace(string(out)) } else { console.ErrorExit(err, "Could not find git HEAD short SHA") } return sha } func IsCwdGitRepo() bool { cmd := exec.Command("git", "rev-parse", "--is-inside-work-tree") err := cmd.Run() return err == nil } ================================================ FILE: git/main_test.go ================================================ package git import ( "io/ioutil" "os" "os/exec" "strings" "testing" ) func TestGetShortSha(t *testing.T) { cwd, err := os.Getwd() if err != nil { t.Error("Could not read current working directory", err) return } dir, err := ioutil.TempDir("", "fargate-tests") if err != nil { t.Error("Could not create temporary directory", err) return } defer os.RemoveAll(dir) os.Chdir(dir) defer os.Chdir(cwd) exec.Command("git", "init").Run() gitCommit := exec.Command("git", "commit", "--allow-empty", "--message", "dummy commit") commitOutput, err := gitCommit.CombinedOutput() if err != nil { t.Errorf("Could not create dummy git commit: %v", err) t.Errorf("Output: %s", commitOutput) t.FailNow() } if shortSha := GetShortSha(); !strings.Contains(string(commitOutput), GetShortSha()) { t.Errorf("expected %s to contain %s", commitOutput, shortSha) } } func TestIsCwdGitRepoAgainstADir(t *testing.T) { cwd, err := os.Getwd() if err != nil { t.Error("Could not read current working directory", err) return } dir, err := ioutil.TempDir("", "fargate-tests") if err != nil { t.Error("Could not create temporary directory", err) return } defer os.RemoveAll(dir) os.Chdir(dir) defer os.Chdir(cwd) if isCwdGitRepo := IsCwdGitRepo(); isCwdGitRepo { t.Errorf("wanted false, got %+v", isCwdGitRepo) } } func TestIsCwdGitRepoAgainstARepo(t *testing.T) { cwd, err := os.Getwd() if err != nil { t.Error("Could not read current working directory", err) return } dir, err := ioutil.TempDir("", "fargate-tests") if err != nil { t.Error("Could not create temporary directory", err) return } defer os.RemoveAll(dir) os.Chdir(dir) defer os.Chdir(cwd) cmd := exec.Command("git", "init") cmd.Run() if isCwdGitRepo := IsCwdGitRepo(); !isCwdGitRepo { t.Errorf("wanted true, got %+v", isCwdGitRepo) } } ================================================ FILE: go.mod ================================================ module github.com/awslabs/fargatecli require ( github.com/aws/aws-sdk-go v1.30.7 github.com/go-ini/ini v1.32.0 // indirect github.com/golang/mock v1.4.3 github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47 github.com/inconshreveable/mousetrap v1.0.0 // indirect github.com/kyokomi/emoji v0.0.0-20161123144355-7e06b236c489 github.com/mattn/go-colorable v0.0.9 // indirect github.com/mattn/go-isatty v0.0.3 // indirect github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff // indirect github.com/spf13/cobra v0.0.3 github.com/spf13/pflag v1.0.2 // indirect golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 golang.org/x/time v0.0.0-20170927054726-6dc17368e09b gopkg.in/ini.v1 v1.42.0 // indirect ) go 1.13 ================================================ FILE: go.sum ================================================ github.com/aws/aws-sdk-go v1.12.70 h1:rMdb/jACFOE7uJ6govc9kS6rzytrRnW2H2NHBCwkowE= github.com/aws/aws-sdk-go v1.12.70/go.mod h1:ZRmQr0FajVIyZ4ZzBYKG5P3ZqPz9IHG41ZoMu1ADI3k= github.com/aws/aws-sdk-go v1.30.7 h1:IaXfqtioP6p9SFAnNfsqdNczbR5UNbYqvcZUSsCAdTY= github.com/aws/aws-sdk-go v1.30.7/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0= github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/go-ini/ini v1.32.0 h1:/MArBHSS0TFR28yPPDK1vPIjt4wUnPBfb81i6iiyKvA= github.com/go-ini/ini v1.32.0/go.mod h1:ByCAeIL28uOIIG0E3PJtZPDL8WnHpFKFOtgjp+3Ies8= github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg= github.com/golang/mock v1.2.0 h1:28o5sBqPkBsMGnC6b4MvE2TzSr5/AT4c/1fLqVGIwlk= github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= github.com/golang/mock v1.3.1 h1:qGJ6qTW+x6xX/my+8YUVl4WNpX9B7+/l2tRsHGZ7f2s= github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y= github.com/golang/mock v1.4.3 h1:GV+pQPG/EUUbkh47niozDcADz6go/dUwhVzdUQHIVRw= github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8= github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY= github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47 h1:UnszMmmmm5vLwWzDjTFVIkfhvWF1NdrmChl8L2NUDCw= github.com/hashicorp/golang-lru v0.0.0-20180201235237-0fb14efe8c47/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8= github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8 h1:12VvqtR6Aowv3l/EQUlocDHW2Cp4G9WJVH7uyH8QFJE= github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= github.com/jmespath/go-jmespath v0.3.0 h1:OS12ieG61fsCg5+qLJ+SsW9NicxNkg3b25OyT2yCeUc= github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik= github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo= github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU= github.com/kyokomi/emoji v0.0.0-20161123144355-7e06b236c489 h1:JXBeCBH4GR1fnaQ3/UIHkVdZVmtQ7yv/8LIEtRbAJPw= github.com/kyokomi/emoji v0.0.0-20161123144355-7e06b236c489/go.mod h1:mZ6aGCD7yk8j6QY6KICwnZ2pxoszVseX1DNoGtU2tBA= github.com/mattn/go-colorable v0.0.9 h1:UVL0vNpWh04HeJXV0KLcaT7r06gOH2l4OW6ddYRUIY4= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-isatty v0.0.3 h1:ns/ykhmWi7G9O+8a448SecJU3nSMBXJfqQkl0upE1jI= github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4= github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff h1:86HlEv0yBCry9syNuylzqznKXDK11p6D0DT596yNMys= github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff/go.mod h1:KSQcGKpxUMHk3nbYzs/tIBAM2iDooCn0BmttHOJEbLs= github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/pflag v1.0.2 h1:Fy0orTDgHdbnzHcsOgfCN4LtHf0ec3wwtiwJqwvf3Gc= github.com/spf13/pflag v1.0.2/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA= golang.org/x/crypto v0.0.0-20180127211104-1875d0a70c90 h1:DNyuYmiOz3AH2rGH1n4YsZUvxVhkeMvSs8s31jiWpm0= golang.org/x/crypto v0.0.0-20180127211104-1875d0a70c90/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2 h1:VklqNMn3ovrHsnt90PveolxSbWFaJdECFbxSq0Mqo2M= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/net v0.0.0-20180202180947-2fb46b16b8dd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a h1:oWX7TPOiFAMXLq8o0ikBYfCJVlRHBcsciT5bXOrH628= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI= golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180202135801-37707fdb30a5 h1:MF92a0wJ3gzSUVBpjcwdrDr5+klMFRNEEu6Mev4n00I= golang.org/x/sys v0.0.0-20180202135801-37707fdb30a5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a h1:1BGLXjeY4akVXGgbC9HugT3Jv3hCI0z56oJR5vAMgBU= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b h1:3X+R0qq1+64izd8es+EttB6qcY+JDlVmAhpRXl7gpzU= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20190425150028-36563e24a262 h1:qsl9y/CJx34tuA7QCPNp86JNJe4spst6Ff8MjvPUdPg= golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/ini.v1 v1.42.0 h1:7N3gPTt50s8GuLortA00n8AqRTk75qOP98+mTPpgzRk= gopkg.in/ini.v1 v1.42.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= ================================================ FILE: iam/main.go ================================================ package iam import ( "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/iam" ) type IAM struct { svc *iam.IAM } func New(sess *session.Session) IAM { return IAM{ svc: iam.New(sess), } } ================================================ FILE: iam/role.go ================================================ package iam import ( "fmt" "os" "github.com/aws/aws-sdk-go/aws" awsiam "github.com/aws/aws-sdk-go/service/iam" ) const ecsTaskExecutionRoleName = "ecsTaskExecutionRole" const ecsTaskExecutionPolicyArn = "arn:aws:iam::aws:policy/service-role/AmazonECSTaskExecutionRolePolicy" const ecsTaskExecutionRoleAssumeRolePolicyDocument = `{ "Version": "2012-10-17", "Statement": [ { "Sid": "", "Effect": "Allow", "Principal": { "Service": "ecs-tasks.amazonaws.com" }, "Action": "sts:AssumeRole" } ] }` func (iam *IAM) CreateEcsTaskExecutionRole() string { getRoleResp, err := iam.svc.GetRole( &awsiam.GetRoleInput{ RoleName: aws.String(ecsTaskExecutionRoleName), }, ) if err == nil { return *getRoleResp.Role.Arn } createRoleResp, err := iam.svc.CreateRole( &awsiam.CreateRoleInput{ AssumeRolePolicyDocument: aws.String(ecsTaskExecutionRoleAssumeRolePolicyDocument), RoleName: aws.String(ecsTaskExecutionRoleName), }, ) if err != nil { fmt.Println(err) os.Exit(1) } ecsTaskExecutionRoleArn := *createRoleResp.Role.Arn _, err = iam.svc.AttachRolePolicy( &awsiam.AttachRolePolicyInput{ RoleName: aws.String(ecsTaskExecutionRoleName), PolicyArn: aws.String(ecsTaskExecutionPolicyArn), }, ) if err != nil { fmt.Println(err) os.Exit(1) } return ecsTaskExecutionRoleArn } ================================================ FILE: main.go ================================================ package main import ( "github.com/awslabs/fargatecli/cmd" ) func main() { cmd.Execute() } ================================================ FILE: route53/hosted_zone.go ================================================ package route53 import ( "sort" "strings" "github.com/aws/aws-sdk-go/aws" awsroute53 "github.com/aws/aws-sdk-go/service/route53" ) const defaultTTL = 86400 // HostedZone is a zone hosted in Amazon Route 53. type HostedZone struct { Name string ID string } func (h HostedZone) isSuperDomainOf(fqdn string) bool { if !strings.HasSuffix(fqdn, ".") { fqdn = fqdn + "." } return strings.HasSuffix(fqdn, h.Name) } // HostedZones is a collection of HostedZones. type HostedZones []HostedZone // FindSuperDomainOf searches a HostedZones collection for the zone that is the superdomain of the // given fully qualified domain name. Returns a HostedZone and a boolean indicating whether a // match was found. func (h HostedZones) FindSuperDomainOf(fqdn string) (HostedZone, bool) { sort.Slice(h, func(i, j int) bool { return len(h[i].Name) > len(h[j].Name) }) for _, zone := range h { if zone.isSuperDomainOf(fqdn) { return zone, true } } return HostedZone{}, false } // CreateAliasInput holds configuration parameters for CreateAlias. type CreateAliasInput struct { HostedZoneID, Name, RecordType, Target, TargetHostedZoneID string } // CreateResourceRecordInput holds configuration parameters for CreateResourceRecord. type CreateResourceRecordInput struct { HostedZoneID, RecordType, Name, Value string } // CreateResourceRecord creates a DNS record in an Amazon Route 53 hosted zone. func (route53 SDKClient) CreateResourceRecord(i CreateResourceRecordInput) (string, error) { change := &awsroute53.Change{ Action: aws.String(awsroute53.ChangeActionUpsert), ResourceRecordSet: &awsroute53.ResourceRecordSet{ Name: aws.String(i.Name), Type: aws.String(i.RecordType), TTL: aws.Int64(defaultTTL), ResourceRecords: []*awsroute53.ResourceRecord{ &awsroute53.ResourceRecord{ Value: aws.String(i.Value), }, }, }, } resp, err := route53.client.ChangeResourceRecordSets( &awsroute53.ChangeResourceRecordSetsInput{ HostedZoneId: aws.String(i.HostedZoneID), ChangeBatch: &awsroute53.ChangeBatch{ Changes: []*awsroute53.Change{change}, }, }, ) if err != nil { return "", err } return aws.StringValue(resp.ChangeInfo.Id), nil } // CreateAlias creates an alias record in an Amazon Route 53 hosted zone. func (route53 SDKClient) CreateAlias(i CreateAliasInput) (string, error) { change := &awsroute53.Change{ Action: aws.String(awsroute53.ChangeActionUpsert), ResourceRecordSet: &awsroute53.ResourceRecordSet{ Name: aws.String(i.Name), Type: aws.String(i.RecordType), AliasTarget: &awsroute53.AliasTarget{ DNSName: aws.String(i.Target), EvaluateTargetHealth: aws.Bool(false), HostedZoneId: aws.String(i.TargetHostedZoneID), }, }, } resp, err := route53.client.ChangeResourceRecordSets( &awsroute53.ChangeResourceRecordSetsInput{ HostedZoneId: aws.String(i.HostedZoneID), ChangeBatch: &awsroute53.ChangeBatch{ Changes: []*awsroute53.Change{change}, }, }, ) if err != nil { return "", err } return aws.StringValue(resp.ChangeInfo.Id), nil } // ListHostedZones returns all Amazon Route 53 zones in the caller's account. func (route53 SDKClient) ListHostedZones() (HostedZones, error) { var hostedZones HostedZones input := &awsroute53.ListHostedZonesInput{} handler := func(resp *awsroute53.ListHostedZonesOutput, lastPage bool) bool { for _, hostedZone := range resp.HostedZones { hostedZones = append( hostedZones, HostedZone{ Name: aws.StringValue(hostedZone.Name), ID: aws.StringValue(hostedZone.Id), }, ) } return true } err := route53.client.ListHostedZonesPages(input, handler) return hostedZones, err } ================================================ FILE: route53/hosted_zone_test.go ================================================ package route53 import ( "errors" "testing" "github.com/aws/aws-sdk-go/aws" awsroute53 "github.com/aws/aws-sdk-go/service/route53" "github.com/golang/mock/gomock" "github.com/awslabs/fargatecli/route53/mock/sdk" ) func TestHostedZonesFindSuperDomainOf(t *testing.T) { examplecom := HostedZone{Name: "example.com."} amazoncom := HostedZone{Name: "amazon.com."} intexamplecom := HostedZone{Name: "int.example.com."} var tests = []struct { fqdn string zones HostedZones zone HostedZone }{ {"staging.example.com", HostedZones{examplecom, amazoncom}, examplecom}, {"mail.int.example.com", HostedZones{examplecom, intexamplecom, amazoncom}, intexamplecom}, {"www.amazon.com", HostedZones{examplecom, intexamplecom, amazoncom}, amazoncom}, } for _, test := range tests { zone, ok := test.zones.FindSuperDomainOf(test.fqdn) if !ok { t.Errorf("No match found for %s, expected %s", test.fqdn, test.zone.Name) } else if zone != test.zone { t.Errorf("Expected %s to be superdomain of %s, got: %s", test.zone.Name, test.fqdn, zone.Name) } } } func TestHostedZonesFindSuperDomainOfNotFound(t *testing.T) { zones := HostedZones{ HostedZone{Name: "zombo.com."}, } zone, ok := zones.FindSuperDomainOf("www.example.com") if ok { t.Errorf("%s matched, expected none", zone.Name) } } func TestListHostedZones(t *testing.T) { resp := &awsroute53.ListHostedZonesOutput{ HostedZones: []*awsroute53.HostedZone{ &awsroute53.HostedZone{Id: aws.String("1"), Name: aws.String("example.com.")}, &awsroute53.HostedZone{Id: aws.String("2"), Name: aws.String("amazon.com.")}, }, } mockClient := sdk.MockListHostedZonesPagesClient{Resp: resp} route53 := SDKClient{client: mockClient} hostedZones, err := route53.ListHostedZones() if err != nil { t.Errorf("Expected no error, got %+v", err) } if len(hostedZones) != 2 { t.Errorf("Expected 2 hosted zones, got %d", len(hostedZones)) } if hostedZones[0].Name != "example.com." { t.Errorf("Expected hosted zone name to be example.com., got %s", hostedZones[0].Name) } } func TestListHostedZonesError(t *testing.T) { mockClient := sdk.MockListHostedZonesPagesClient{ Error: errors.New("boom"), Resp: &awsroute53.ListHostedZonesOutput{}, } route53 := SDKClient{client: mockClient} hostedZones, err := route53.ListHostedZones() if err == nil { t.Error("Expected error, got none") } if len(hostedZones) > 0 { t.Errorf("Expected no hosted zones, got %d", len(hostedZones)) } } func TestCreateResourceRecord(t *testing.T) { hostedZoneID := "zone1" hostedZone := HostedZone{Name: "example.com", ID: hostedZoneID} recordType := "CNAME" name := "www.example.com" value := "example.hosted-websites.com" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53API := sdk.NewMockRoute53API(mockCtrl) route53 := SDKClient{client: mockRoute53API} i := &awsroute53.ChangeResourceRecordSetsInput{ HostedZoneId: aws.String(hostedZoneID), ChangeBatch: &awsroute53.ChangeBatch{ Changes: []*awsroute53.Change{ &awsroute53.Change{ Action: aws.String(awsroute53.ChangeActionUpsert), ResourceRecordSet: &awsroute53.ResourceRecordSet{ Name: aws.String(name), Type: aws.String(recordType), TTL: aws.Int64(defaultTTL), ResourceRecords: []*awsroute53.ResourceRecord{ &awsroute53.ResourceRecord{ Value: aws.String(value), }, }, }, }, }, }, } o := &awsroute53.ChangeResourceRecordSetsOutput{ ChangeInfo: &awsroute53.ChangeInfo{ Id: aws.String("1"), }, } mockRoute53API.EXPECT().ChangeResourceRecordSets(i).Return(o, nil) id, err := route53.CreateResourceRecord( CreateResourceRecordInput{ HostedZoneID: hostedZone.ID, RecordType: recordType, Name: name, Value: value, }, ) if id != "1" { t.Errorf("Expected id == 1, got %s", id) } if err != nil { t.Errorf("Expected no error, got %v", err) } } func TestCreateAliasRecord(t *testing.T) { hostedZoneID := "zone1" targetHostedZoneID := "zone2" hostedZone := HostedZone{Name: "example.com", ID: hostedZoneID} recordType := "A" name := "www.example.com" target := "example.load-balancers.com" mockCtrl := gomock.NewController(t) defer mockCtrl.Finish() mockRoute53API := sdk.NewMockRoute53API(mockCtrl) route53 := SDKClient{client: mockRoute53API} i := &awsroute53.ChangeResourceRecordSetsInput{ HostedZoneId: aws.String(hostedZoneID), ChangeBatch: &awsroute53.ChangeBatch{ Changes: []*awsroute53.Change{ &awsroute53.Change{ Action: aws.String(awsroute53.ChangeActionUpsert), ResourceRecordSet: &awsroute53.ResourceRecordSet{ Name: aws.String(name), Type: aws.String(recordType), AliasTarget: &awsroute53.AliasTarget{ DNSName: aws.String(target), EvaluateTargetHealth: aws.Bool(false), HostedZoneId: aws.String(targetHostedZoneID), }, }, }, }, }, } o := &awsroute53.ChangeResourceRecordSetsOutput{ ChangeInfo: &awsroute53.ChangeInfo{ Id: aws.String("2"), }, } mockRoute53API.EXPECT().ChangeResourceRecordSets(i).Return(o, nil) id, err := route53.CreateAlias( CreateAliasInput{ HostedZoneID: hostedZone.ID, RecordType: recordType, Name: name, Target: target, TargetHostedZoneID: targetHostedZoneID, }, ) if id != "2" { t.Errorf("Expected id == 2, got %s", id) } if err != nil { t.Errorf("Expected no error, got %v", err) } } ================================================ FILE: route53/main.go ================================================ package route53 //go:generate mockgen -package client -destination=mock/client/client.go github.com/awslabs/fargatecli/route53 Client //go:generate mockgen -package sdk -source ../vendor/github.com/aws/aws-sdk-go/service/route53/route53iface/interface.go -destination=mock/sdk/route53iface.go github.com/aws/aws-sdk-go/service/route53/route53iface Route53API import ( "github.com/aws/aws-sdk-go/aws/session" "github.com/aws/aws-sdk-go/service/route53" "github.com/aws/aws-sdk-go/service/route53/route53iface" ) // Client represents a method for accessing Amazon Route 53. type Client interface { CreateAlias(CreateAliasInput) (string, error) CreateResourceRecord(CreateResourceRecordInput) (string, error) ListHostedZones() (HostedZones, error) } // SDKClient implements access to Amazon Route 53 via the AWS SDK. type SDKClient struct { client route53iface.Route53API } // New returns an SDKClient configured with the given session. func New(sess *session.Session) SDKClient { return SDKClient{ client: route53.New(sess), } } ================================================ FILE: route53/mock/client/client.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: github.com/awslabs/fargatecli/route53 (interfaces: Client) // Package client is a generated GoMock package. package client import ( route53 "github.com/awslabs/fargatecli/route53" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockClient is a mock of Client interface type MockClient struct { ctrl *gomock.Controller recorder *MockClientMockRecorder } // MockClientMockRecorder is the mock recorder for MockClient type MockClientMockRecorder struct { mock *MockClient } // NewMockClient creates a new mock instance func NewMockClient(ctrl *gomock.Controller) *MockClient { mock := &MockClient{ctrl: ctrl} mock.recorder = &MockClientMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockClient) EXPECT() *MockClientMockRecorder { return m.recorder } // CreateAlias mocks base method func (m *MockClient) CreateAlias(arg0 route53.CreateAliasInput) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateAlias", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateAlias indicates an expected call of CreateAlias func (mr *MockClientMockRecorder) CreateAlias(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAlias", reflect.TypeOf((*MockClient)(nil).CreateAlias), arg0) } // CreateResourceRecord mocks base method func (m *MockClient) CreateResourceRecord(arg0 route53.CreateResourceRecordInput) (string, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateResourceRecord", arg0) ret0, _ := ret[0].(string) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateResourceRecord indicates an expected call of CreateResourceRecord func (mr *MockClientMockRecorder) CreateResourceRecord(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceRecord", reflect.TypeOf((*MockClient)(nil).CreateResourceRecord), arg0) } // ListHostedZones mocks base method func (m *MockClient) ListHostedZones() (route53.HostedZones, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZones") ret0, _ := ret[0].(route53.HostedZones) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHostedZones indicates an expected call of ListHostedZones func (mr *MockClientMockRecorder) ListHostedZones() *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZones", reflect.TypeOf((*MockClient)(nil).ListHostedZones)) } ================================================ FILE: route53/mock/sdk/paginators.go ================================================ package sdk import ( "github.com/aws/aws-sdk-go/service/route53" "github.com/aws/aws-sdk-go/service/route53/route53iface" ) type MockListHostedZonesPagesClient struct { route53iface.Route53API Resp *route53.ListHostedZonesOutput Error error } func (m MockListHostedZonesPagesClient) ListHostedZonesPages(in *route53.ListHostedZonesInput, fn func(*route53.ListHostedZonesOutput, bool) bool) error { if m.Error != nil { return m.Error } fn(m.Resp, true) return nil } ================================================ FILE: route53/mock/sdk/route53iface.go ================================================ // Code generated by MockGen. DO NOT EDIT. // Source: ../vendor/github.com/aws/aws-sdk-go/service/route53/route53iface/interface.go // Package sdk is a generated GoMock package. package sdk import ( aws "github.com/aws/aws-sdk-go/aws" request "github.com/aws/aws-sdk-go/aws/request" route53 "github.com/aws/aws-sdk-go/service/route53" gomock "github.com/golang/mock/gomock" reflect "reflect" ) // MockRoute53API is a mock of Route53API interface type MockRoute53API struct { ctrl *gomock.Controller recorder *MockRoute53APIMockRecorder } // MockRoute53APIMockRecorder is the mock recorder for MockRoute53API type MockRoute53APIMockRecorder struct { mock *MockRoute53API } // NewMockRoute53API creates a new mock instance func NewMockRoute53API(ctrl *gomock.Controller) *MockRoute53API { mock := &MockRoute53API{ctrl: ctrl} mock.recorder = &MockRoute53APIMockRecorder{mock} return mock } // EXPECT returns an object that allows the caller to indicate expected use func (m *MockRoute53API) EXPECT() *MockRoute53APIMockRecorder { return m.recorder } // AssociateVPCWithHostedZone mocks base method func (m *MockRoute53API) AssociateVPCWithHostedZone(arg0 *route53.AssociateVPCWithHostedZoneInput) (*route53.AssociateVPCWithHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AssociateVPCWithHostedZone", arg0) ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssociateVPCWithHostedZone indicates an expected call of AssociateVPCWithHostedZone func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZone", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZone), arg0) } // AssociateVPCWithHostedZoneWithContext mocks base method func (m *MockRoute53API) AssociateVPCWithHostedZoneWithContext(arg0 aws.Context, arg1 *route53.AssociateVPCWithHostedZoneInput, arg2 ...request.Option) (*route53.AssociateVPCWithHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.AssociateVPCWithHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // AssociateVPCWithHostedZoneWithContext indicates an expected call of AssociateVPCWithHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneWithContext), varargs...) } // AssociateVPCWithHostedZoneRequest mocks base method func (m *MockRoute53API) AssociateVPCWithHostedZoneRequest(arg0 *route53.AssociateVPCWithHostedZoneInput) (*request.Request, *route53.AssociateVPCWithHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "AssociateVPCWithHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.AssociateVPCWithHostedZoneOutput) return ret0, ret1 } // AssociateVPCWithHostedZoneRequest indicates an expected call of AssociateVPCWithHostedZoneRequest func (mr *MockRoute53APIMockRecorder) AssociateVPCWithHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVPCWithHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).AssociateVPCWithHostedZoneRequest), arg0) } // ChangeResourceRecordSets mocks base method func (m *MockRoute53API) ChangeResourceRecordSets(arg0 *route53.ChangeResourceRecordSetsInput) (*route53.ChangeResourceRecordSetsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChangeResourceRecordSets", arg0) ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ChangeResourceRecordSets indicates an expected call of ChangeResourceRecordSets func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSets), arg0) } // ChangeResourceRecordSetsWithContext mocks base method func (m *MockRoute53API) ChangeResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ChangeResourceRecordSetsInput, arg2 ...request.Option) (*route53.ChangeResourceRecordSetsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ChangeResourceRecordSetsWithContext", varargs...) ret0, _ := ret[0].(*route53.ChangeResourceRecordSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ChangeResourceRecordSetsWithContext indicates an expected call of ChangeResourceRecordSetsWithContext func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsWithContext), varargs...) } // ChangeResourceRecordSetsRequest mocks base method func (m *MockRoute53API) ChangeResourceRecordSetsRequest(arg0 *route53.ChangeResourceRecordSetsInput) (*request.Request, *route53.ChangeResourceRecordSetsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChangeResourceRecordSetsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ChangeResourceRecordSetsOutput) return ret0, ret1 } // ChangeResourceRecordSetsRequest indicates an expected call of ChangeResourceRecordSetsRequest func (mr *MockRoute53APIMockRecorder) ChangeResourceRecordSetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeResourceRecordSetsRequest), arg0) } // ChangeTagsForResource mocks base method func (m *MockRoute53API) ChangeTagsForResource(arg0 *route53.ChangeTagsForResourceInput) (*route53.ChangeTagsForResourceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChangeTagsForResource", arg0) ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ChangeTagsForResource indicates an expected call of ChangeTagsForResource func (mr *MockRoute53APIMockRecorder) ChangeTagsForResource(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResource), arg0) } // ChangeTagsForResourceWithContext mocks base method func (m *MockRoute53API) ChangeTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ChangeTagsForResourceInput, arg2 ...request.Option) (*route53.ChangeTagsForResourceOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ChangeTagsForResourceWithContext", varargs...) ret0, _ := ret[0].(*route53.ChangeTagsForResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ChangeTagsForResourceWithContext indicates an expected call of ChangeTagsForResourceWithContext func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceWithContext", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceWithContext), varargs...) } // ChangeTagsForResourceRequest mocks base method func (m *MockRoute53API) ChangeTagsForResourceRequest(arg0 *route53.ChangeTagsForResourceInput) (*request.Request, *route53.ChangeTagsForResourceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChangeTagsForResourceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ChangeTagsForResourceOutput) return ret0, ret1 } // ChangeTagsForResourceRequest indicates an expected call of ChangeTagsForResourceRequest func (mr *MockRoute53APIMockRecorder) ChangeTagsForResourceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangeTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ChangeTagsForResourceRequest), arg0) } // CreateHealthCheck mocks base method func (m *MockRoute53API) CreateHealthCheck(arg0 *route53.CreateHealthCheckInput) (*route53.CreateHealthCheckOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateHealthCheck", arg0) ret0, _ := ret[0].(*route53.CreateHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateHealthCheck indicates an expected call of CreateHealthCheck func (mr *MockRoute53APIMockRecorder) CreateHealthCheck(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheck), arg0) } // CreateHealthCheckWithContext mocks base method func (m *MockRoute53API) CreateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.CreateHealthCheckInput, arg2 ...request.Option) (*route53.CreateHealthCheckOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateHealthCheckWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateHealthCheckWithContext indicates an expected call of CreateHealthCheckWithContext func (mr *MockRoute53APIMockRecorder) CreateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckWithContext), varargs...) } // CreateHealthCheckRequest mocks base method func (m *MockRoute53API) CreateHealthCheckRequest(arg0 *route53.CreateHealthCheckInput) (*request.Request, *route53.CreateHealthCheckOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateHealthCheckRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateHealthCheckOutput) return ret0, ret1 } // CreateHealthCheckRequest indicates an expected call of CreateHealthCheckRequest func (mr *MockRoute53APIMockRecorder) CreateHealthCheckRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHealthCheckRequest), arg0) } // CreateHostedZone mocks base method func (m *MockRoute53API) CreateHostedZone(arg0 *route53.CreateHostedZoneInput) (*route53.CreateHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateHostedZone", arg0) ret0, _ := ret[0].(*route53.CreateHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateHostedZone indicates an expected call of CreateHostedZone func (mr *MockRoute53APIMockRecorder) CreateHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZone", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZone), arg0) } // CreateHostedZoneWithContext mocks base method func (m *MockRoute53API) CreateHostedZoneWithContext(arg0 aws.Context, arg1 *route53.CreateHostedZoneInput, arg2 ...request.Option) (*route53.CreateHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateHostedZoneWithContext indicates an expected call of CreateHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) CreateHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneWithContext), varargs...) } // CreateHostedZoneRequest mocks base method func (m *MockRoute53API) CreateHostedZoneRequest(arg0 *route53.CreateHostedZoneInput) (*request.Request, *route53.CreateHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateHostedZoneOutput) return ret0, ret1 } // CreateHostedZoneRequest indicates an expected call of CreateHostedZoneRequest func (mr *MockRoute53APIMockRecorder) CreateHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateHostedZoneRequest), arg0) } // CreateQueryLoggingConfig mocks base method func (m *MockRoute53API) CreateQueryLoggingConfig(arg0 *route53.CreateQueryLoggingConfigInput) (*route53.CreateQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateQueryLoggingConfig", arg0) ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateQueryLoggingConfig indicates an expected call of CreateQueryLoggingConfig func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfig(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfig), arg0) } // CreateQueryLoggingConfigWithContext mocks base method func (m *MockRoute53API) CreateQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.CreateQueryLoggingConfigInput, arg2 ...request.Option) (*route53.CreateQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateQueryLoggingConfigWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateQueryLoggingConfigWithContext indicates an expected call of CreateQueryLoggingConfigWithContext func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigWithContext), varargs...) } // CreateQueryLoggingConfigRequest mocks base method func (m *MockRoute53API) CreateQueryLoggingConfigRequest(arg0 *route53.CreateQueryLoggingConfigInput) (*request.Request, *route53.CreateQueryLoggingConfigOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateQueryLoggingConfigRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateQueryLoggingConfigOutput) return ret0, ret1 } // CreateQueryLoggingConfigRequest indicates an expected call of CreateQueryLoggingConfigRequest func (mr *MockRoute53APIMockRecorder) CreateQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateQueryLoggingConfigRequest), arg0) } // CreateReusableDelegationSet mocks base method func (m *MockRoute53API) CreateReusableDelegationSet(arg0 *route53.CreateReusableDelegationSetInput) (*route53.CreateReusableDelegationSetOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateReusableDelegationSet", arg0) ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateReusableDelegationSet indicates an expected call of CreateReusableDelegationSet func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSet), arg0) } // CreateReusableDelegationSetWithContext mocks base method func (m *MockRoute53API) CreateReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.CreateReusableDelegationSetInput, arg2 ...request.Option) (*route53.CreateReusableDelegationSetOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateReusableDelegationSetWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateReusableDelegationSetWithContext indicates an expected call of CreateReusableDelegationSetWithContext func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetWithContext), varargs...) } // CreateReusableDelegationSetRequest mocks base method func (m *MockRoute53API) CreateReusableDelegationSetRequest(arg0 *route53.CreateReusableDelegationSetInput) (*request.Request, *route53.CreateReusableDelegationSetOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateReusableDelegationSetRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateReusableDelegationSetOutput) return ret0, ret1 } // CreateReusableDelegationSetRequest indicates an expected call of CreateReusableDelegationSetRequest func (mr *MockRoute53APIMockRecorder) CreateReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateReusableDelegationSetRequest), arg0) } // CreateTrafficPolicy mocks base method func (m *MockRoute53API) CreateTrafficPolicy(arg0 *route53.CreateTrafficPolicyInput) (*route53.CreateTrafficPolicyOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicy", arg0) ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicy indicates an expected call of CreateTrafficPolicy func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicy(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicy), arg0) } // CreateTrafficPolicyWithContext mocks base method func (m *MockRoute53API) CreateTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateTrafficPolicyWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicyWithContext indicates an expected call of CreateTrafficPolicyWithContext func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyWithContext), varargs...) } // CreateTrafficPolicyRequest mocks base method func (m *MockRoute53API) CreateTrafficPolicyRequest(arg0 *route53.CreateTrafficPolicyInput) (*request.Request, *route53.CreateTrafficPolicyOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicyRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateTrafficPolicyOutput) return ret0, ret1 } // CreateTrafficPolicyRequest indicates an expected call of CreateTrafficPolicyRequest func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyRequest), arg0) } // CreateTrafficPolicyInstance mocks base method func (m *MockRoute53API) CreateTrafficPolicyInstance(arg0 *route53.CreateTrafficPolicyInstanceInput) (*route53.CreateTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicyInstance", arg0) ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicyInstance indicates an expected call of CreateTrafficPolicyInstance func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstance), arg0) } // CreateTrafficPolicyInstanceWithContext mocks base method func (m *MockRoute53API) CreateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicyInstanceWithContext indicates an expected call of CreateTrafficPolicyInstanceWithContext func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceWithContext), varargs...) } // CreateTrafficPolicyInstanceRequest mocks base method func (m *MockRoute53API) CreateTrafficPolicyInstanceRequest(arg0 *route53.CreateTrafficPolicyInstanceInput) (*request.Request, *route53.CreateTrafficPolicyInstanceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicyInstanceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateTrafficPolicyInstanceOutput) return ret0, ret1 } // CreateTrafficPolicyInstanceRequest indicates an expected call of CreateTrafficPolicyInstanceRequest func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyInstanceRequest), arg0) } // CreateTrafficPolicyVersion mocks base method func (m *MockRoute53API) CreateTrafficPolicyVersion(arg0 *route53.CreateTrafficPolicyVersionInput) (*route53.CreateTrafficPolicyVersionOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicyVersion", arg0) ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicyVersion indicates an expected call of CreateTrafficPolicyVersion func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersion(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersion", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersion), arg0) } // CreateTrafficPolicyVersionWithContext mocks base method func (m *MockRoute53API) CreateTrafficPolicyVersionWithContext(arg0 aws.Context, arg1 *route53.CreateTrafficPolicyVersionInput, arg2 ...request.Option) (*route53.CreateTrafficPolicyVersionOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateTrafficPolicyVersionOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateTrafficPolicyVersionWithContext indicates an expected call of CreateTrafficPolicyVersionWithContext func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionWithContext), varargs...) } // CreateTrafficPolicyVersionRequest mocks base method func (m *MockRoute53API) CreateTrafficPolicyVersionRequest(arg0 *route53.CreateTrafficPolicyVersionInput) (*request.Request, *route53.CreateTrafficPolicyVersionOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateTrafficPolicyVersionRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateTrafficPolicyVersionOutput) return ret0, ret1 } // CreateTrafficPolicyVersionRequest indicates an expected call of CreateTrafficPolicyVersionRequest func (mr *MockRoute53APIMockRecorder) CreateTrafficPolicyVersionRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficPolicyVersionRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateTrafficPolicyVersionRequest), arg0) } // CreateVPCAssociationAuthorization mocks base method func (m *MockRoute53API) CreateVPCAssociationAuthorization(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*route53.CreateVPCAssociationAuthorizationOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorization", arg0) ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateVPCAssociationAuthorization indicates an expected call of CreateVPCAssociationAuthorization func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorization(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorization), arg0) } // CreateVPCAssociationAuthorizationWithContext mocks base method func (m *MockRoute53API) CreateVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.CreateVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.CreateVPCAssociationAuthorizationOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationWithContext", varargs...) ret0, _ := ret[0].(*route53.CreateVPCAssociationAuthorizationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // CreateVPCAssociationAuthorizationWithContext indicates an expected call of CreateVPCAssociationAuthorizationWithContext func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationWithContext), varargs...) } // CreateVPCAssociationAuthorizationRequest mocks base method func (m *MockRoute53API) CreateVPCAssociationAuthorizationRequest(arg0 *route53.CreateVPCAssociationAuthorizationInput) (*request.Request, *route53.CreateVPCAssociationAuthorizationOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "CreateVPCAssociationAuthorizationRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.CreateVPCAssociationAuthorizationOutput) return ret0, ret1 } // CreateVPCAssociationAuthorizationRequest indicates an expected call of CreateVPCAssociationAuthorizationRequest func (mr *MockRoute53APIMockRecorder) CreateVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).CreateVPCAssociationAuthorizationRequest), arg0) } // DeleteHealthCheck mocks base method func (m *MockRoute53API) DeleteHealthCheck(arg0 *route53.DeleteHealthCheckInput) (*route53.DeleteHealthCheckOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteHealthCheck", arg0) ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteHealthCheck indicates an expected call of DeleteHealthCheck func (mr *MockRoute53APIMockRecorder) DeleteHealthCheck(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheck), arg0) } // DeleteHealthCheckWithContext mocks base method func (m *MockRoute53API) DeleteHealthCheckWithContext(arg0 aws.Context, arg1 *route53.DeleteHealthCheckInput, arg2 ...request.Option) (*route53.DeleteHealthCheckOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteHealthCheckWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteHealthCheckWithContext indicates an expected call of DeleteHealthCheckWithContext func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckWithContext), varargs...) } // DeleteHealthCheckRequest mocks base method func (m *MockRoute53API) DeleteHealthCheckRequest(arg0 *route53.DeleteHealthCheckInput) (*request.Request, *route53.DeleteHealthCheckOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteHealthCheckRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteHealthCheckOutput) return ret0, ret1 } // DeleteHealthCheckRequest indicates an expected call of DeleteHealthCheckRequest func (mr *MockRoute53APIMockRecorder) DeleteHealthCheckRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHealthCheckRequest), arg0) } // DeleteHostedZone mocks base method func (m *MockRoute53API) DeleteHostedZone(arg0 *route53.DeleteHostedZoneInput) (*route53.DeleteHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteHostedZone", arg0) ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteHostedZone indicates an expected call of DeleteHostedZone func (mr *MockRoute53APIMockRecorder) DeleteHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZone), arg0) } // DeleteHostedZoneWithContext mocks base method func (m *MockRoute53API) DeleteHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DeleteHostedZoneInput, arg2 ...request.Option) (*route53.DeleteHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteHostedZoneWithContext indicates an expected call of DeleteHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneWithContext), varargs...) } // DeleteHostedZoneRequest mocks base method func (m *MockRoute53API) DeleteHostedZoneRequest(arg0 *route53.DeleteHostedZoneInput) (*request.Request, *route53.DeleteHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteHostedZoneOutput) return ret0, ret1 } // DeleteHostedZoneRequest indicates an expected call of DeleteHostedZoneRequest func (mr *MockRoute53APIMockRecorder) DeleteHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteHostedZoneRequest), arg0) } // DeleteQueryLoggingConfig mocks base method func (m *MockRoute53API) DeleteQueryLoggingConfig(arg0 *route53.DeleteQueryLoggingConfigInput) (*route53.DeleteQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteQueryLoggingConfig", arg0) ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteQueryLoggingConfig indicates an expected call of DeleteQueryLoggingConfig func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfig(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfig), arg0) } // DeleteQueryLoggingConfigWithContext mocks base method func (m *MockRoute53API) DeleteQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.DeleteQueryLoggingConfigInput, arg2 ...request.Option) (*route53.DeleteQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteQueryLoggingConfigWithContext indicates an expected call of DeleteQueryLoggingConfigWithContext func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigWithContext), varargs...) } // DeleteQueryLoggingConfigRequest mocks base method func (m *MockRoute53API) DeleteQueryLoggingConfigRequest(arg0 *route53.DeleteQueryLoggingConfigInput) (*request.Request, *route53.DeleteQueryLoggingConfigOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteQueryLoggingConfigRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteQueryLoggingConfigOutput) return ret0, ret1 } // DeleteQueryLoggingConfigRequest indicates an expected call of DeleteQueryLoggingConfigRequest func (mr *MockRoute53APIMockRecorder) DeleteQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteQueryLoggingConfigRequest), arg0) } // DeleteReusableDelegationSet mocks base method func (m *MockRoute53API) DeleteReusableDelegationSet(arg0 *route53.DeleteReusableDelegationSetInput) (*route53.DeleteReusableDelegationSetOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteReusableDelegationSet", arg0) ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteReusableDelegationSet indicates an expected call of DeleteReusableDelegationSet func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSet), arg0) } // DeleteReusableDelegationSetWithContext mocks base method func (m *MockRoute53API) DeleteReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.DeleteReusableDelegationSetInput, arg2 ...request.Option) (*route53.DeleteReusableDelegationSetOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteReusableDelegationSetWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteReusableDelegationSetWithContext indicates an expected call of DeleteReusableDelegationSetWithContext func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetWithContext), varargs...) } // DeleteReusableDelegationSetRequest mocks base method func (m *MockRoute53API) DeleteReusableDelegationSetRequest(arg0 *route53.DeleteReusableDelegationSetInput) (*request.Request, *route53.DeleteReusableDelegationSetOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteReusableDelegationSetRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteReusableDelegationSetOutput) return ret0, ret1 } // DeleteReusableDelegationSetRequest indicates an expected call of DeleteReusableDelegationSetRequest func (mr *MockRoute53APIMockRecorder) DeleteReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteReusableDelegationSetRequest), arg0) } // DeleteTrafficPolicy mocks base method func (m *MockRoute53API) DeleteTrafficPolicy(arg0 *route53.DeleteTrafficPolicyInput) (*route53.DeleteTrafficPolicyOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTrafficPolicy", arg0) ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTrafficPolicy indicates an expected call of DeleteTrafficPolicy func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicy(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicy), arg0) } // DeleteTrafficPolicyWithContext mocks base method func (m *MockRoute53API) DeleteTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteTrafficPolicyWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTrafficPolicyWithContext indicates an expected call of DeleteTrafficPolicyWithContext func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyWithContext), varargs...) } // DeleteTrafficPolicyRequest mocks base method func (m *MockRoute53API) DeleteTrafficPolicyRequest(arg0 *route53.DeleteTrafficPolicyInput) (*request.Request, *route53.DeleteTrafficPolicyOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTrafficPolicyRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteTrafficPolicyOutput) return ret0, ret1 } // DeleteTrafficPolicyRequest indicates an expected call of DeleteTrafficPolicyRequest func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyRequest), arg0) } // DeleteTrafficPolicyInstance mocks base method func (m *MockRoute53API) DeleteTrafficPolicyInstance(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*route53.DeleteTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstance", arg0) ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTrafficPolicyInstance indicates an expected call of DeleteTrafficPolicyInstance func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstance), arg0) } // DeleteTrafficPolicyInstanceWithContext mocks base method func (m *MockRoute53API) DeleteTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.DeleteTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.DeleteTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteTrafficPolicyInstanceWithContext indicates an expected call of DeleteTrafficPolicyInstanceWithContext func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceWithContext), varargs...) } // DeleteTrafficPolicyInstanceRequest mocks base method func (m *MockRoute53API) DeleteTrafficPolicyInstanceRequest(arg0 *route53.DeleteTrafficPolicyInstanceInput) (*request.Request, *route53.DeleteTrafficPolicyInstanceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteTrafficPolicyInstanceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteTrafficPolicyInstanceOutput) return ret0, ret1 } // DeleteTrafficPolicyInstanceRequest indicates an expected call of DeleteTrafficPolicyInstanceRequest func (mr *MockRoute53APIMockRecorder) DeleteTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteTrafficPolicyInstanceRequest), arg0) } // DeleteVPCAssociationAuthorization mocks base method func (m *MockRoute53API) DeleteVPCAssociationAuthorization(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*route53.DeleteVPCAssociationAuthorizationOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorization", arg0) ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteVPCAssociationAuthorization indicates an expected call of DeleteVPCAssociationAuthorization func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorization(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorization", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorization), arg0) } // DeleteVPCAssociationAuthorizationWithContext mocks base method func (m *MockRoute53API) DeleteVPCAssociationAuthorizationWithContext(arg0 aws.Context, arg1 *route53.DeleteVPCAssociationAuthorizationInput, arg2 ...request.Option) (*route53.DeleteVPCAssociationAuthorizationOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationWithContext", varargs...) ret0, _ := ret[0].(*route53.DeleteVPCAssociationAuthorizationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DeleteVPCAssociationAuthorizationWithContext indicates an expected call of DeleteVPCAssociationAuthorizationWithContext func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationWithContext", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationWithContext), varargs...) } // DeleteVPCAssociationAuthorizationRequest mocks base method func (m *MockRoute53API) DeleteVPCAssociationAuthorizationRequest(arg0 *route53.DeleteVPCAssociationAuthorizationInput) (*request.Request, *route53.DeleteVPCAssociationAuthorizationOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DeleteVPCAssociationAuthorizationRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DeleteVPCAssociationAuthorizationOutput) return ret0, ret1 } // DeleteVPCAssociationAuthorizationRequest indicates an expected call of DeleteVPCAssociationAuthorizationRequest func (mr *MockRoute53APIMockRecorder) DeleteVPCAssociationAuthorizationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVPCAssociationAuthorizationRequest", reflect.TypeOf((*MockRoute53API)(nil).DeleteVPCAssociationAuthorizationRequest), arg0) } // DisassociateVPCFromHostedZone mocks base method func (m *MockRoute53API) DisassociateVPCFromHostedZone(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*route53.DisassociateVPCFromHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZone", arg0) ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DisassociateVPCFromHostedZone indicates an expected call of DisassociateVPCFromHostedZone func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZone", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZone), arg0) } // DisassociateVPCFromHostedZoneWithContext mocks base method func (m *MockRoute53API) DisassociateVPCFromHostedZoneWithContext(arg0 aws.Context, arg1 *route53.DisassociateVPCFromHostedZoneInput, arg2 ...request.Option) (*route53.DisassociateVPCFromHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.DisassociateVPCFromHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // DisassociateVPCFromHostedZoneWithContext indicates an expected call of DisassociateVPCFromHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneWithContext), varargs...) } // DisassociateVPCFromHostedZoneRequest mocks base method func (m *MockRoute53API) DisassociateVPCFromHostedZoneRequest(arg0 *route53.DisassociateVPCFromHostedZoneInput) (*request.Request, *route53.DisassociateVPCFromHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "DisassociateVPCFromHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.DisassociateVPCFromHostedZoneOutput) return ret0, ret1 } // DisassociateVPCFromHostedZoneRequest indicates an expected call of DisassociateVPCFromHostedZoneRequest func (mr *MockRoute53APIMockRecorder) DisassociateVPCFromHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVPCFromHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).DisassociateVPCFromHostedZoneRequest), arg0) } // GetAccountLimit mocks base method func (m *MockRoute53API) GetAccountLimit(arg0 *route53.GetAccountLimitInput) (*route53.GetAccountLimitOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAccountLimit", arg0) ret0, _ := ret[0].(*route53.GetAccountLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAccountLimit indicates an expected call of GetAccountLimit func (mr *MockRoute53APIMockRecorder) GetAccountLimit(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimit", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimit), arg0) } // GetAccountLimitWithContext mocks base method func (m *MockRoute53API) GetAccountLimitWithContext(arg0 aws.Context, arg1 *route53.GetAccountLimitInput, arg2 ...request.Option) (*route53.GetAccountLimitOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetAccountLimitWithContext", varargs...) ret0, _ := ret[0].(*route53.GetAccountLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetAccountLimitWithContext indicates an expected call of GetAccountLimitWithContext func (mr *MockRoute53APIMockRecorder) GetAccountLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitWithContext), varargs...) } // GetAccountLimitRequest mocks base method func (m *MockRoute53API) GetAccountLimitRequest(arg0 *route53.GetAccountLimitInput) (*request.Request, *route53.GetAccountLimitOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetAccountLimitRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetAccountLimitOutput) return ret0, ret1 } // GetAccountLimitRequest indicates an expected call of GetAccountLimitRequest func (mr *MockRoute53APIMockRecorder) GetAccountLimitRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetAccountLimitRequest), arg0) } // GetChange mocks base method func (m *MockRoute53API) GetChange(arg0 *route53.GetChangeInput) (*route53.GetChangeOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetChange", arg0) ret0, _ := ret[0].(*route53.GetChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetChange indicates an expected call of GetChange func (mr *MockRoute53APIMockRecorder) GetChange(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChange", reflect.TypeOf((*MockRoute53API)(nil).GetChange), arg0) } // GetChangeWithContext mocks base method func (m *MockRoute53API) GetChangeWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, arg2 ...request.Option) (*route53.GetChangeOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetChangeWithContext", varargs...) ret0, _ := ret[0].(*route53.GetChangeOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetChangeWithContext indicates an expected call of GetChangeWithContext func (mr *MockRoute53APIMockRecorder) GetChangeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetChangeWithContext), varargs...) } // GetChangeRequest mocks base method func (m *MockRoute53API) GetChangeRequest(arg0 *route53.GetChangeInput) (*request.Request, *route53.GetChangeOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetChangeRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetChangeOutput) return ret0, ret1 } // GetChangeRequest indicates an expected call of GetChangeRequest func (mr *MockRoute53APIMockRecorder) GetChangeRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChangeRequest", reflect.TypeOf((*MockRoute53API)(nil).GetChangeRequest), arg0) } // GetCheckerIpRanges mocks base method func (m *MockRoute53API) GetCheckerIpRanges(arg0 *route53.GetCheckerIpRangesInput) (*route53.GetCheckerIpRangesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCheckerIpRanges", arg0) ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCheckerIpRanges indicates an expected call of GetCheckerIpRanges func (mr *MockRoute53APIMockRecorder) GetCheckerIpRanges(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRanges", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRanges), arg0) } // GetCheckerIpRangesWithContext mocks base method func (m *MockRoute53API) GetCheckerIpRangesWithContext(arg0 aws.Context, arg1 *route53.GetCheckerIpRangesInput, arg2 ...request.Option) (*route53.GetCheckerIpRangesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetCheckerIpRangesWithContext", varargs...) ret0, _ := ret[0].(*route53.GetCheckerIpRangesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetCheckerIpRangesWithContext indicates an expected call of GetCheckerIpRangesWithContext func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesWithContext), varargs...) } // GetCheckerIpRangesRequest mocks base method func (m *MockRoute53API) GetCheckerIpRangesRequest(arg0 *route53.GetCheckerIpRangesInput) (*request.Request, *route53.GetCheckerIpRangesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetCheckerIpRangesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetCheckerIpRangesOutput) return ret0, ret1 } // GetCheckerIpRangesRequest indicates an expected call of GetCheckerIpRangesRequest func (mr *MockRoute53APIMockRecorder) GetCheckerIpRangesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCheckerIpRangesRequest", reflect.TypeOf((*MockRoute53API)(nil).GetCheckerIpRangesRequest), arg0) } // GetGeoLocation mocks base method func (m *MockRoute53API) GetGeoLocation(arg0 *route53.GetGeoLocationInput) (*route53.GetGeoLocationOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetGeoLocation", arg0) ret0, _ := ret[0].(*route53.GetGeoLocationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetGeoLocation indicates an expected call of GetGeoLocation func (mr *MockRoute53APIMockRecorder) GetGeoLocation(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocation", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocation), arg0) } // GetGeoLocationWithContext mocks base method func (m *MockRoute53API) GetGeoLocationWithContext(arg0 aws.Context, arg1 *route53.GetGeoLocationInput, arg2 ...request.Option) (*route53.GetGeoLocationOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetGeoLocationWithContext", varargs...) ret0, _ := ret[0].(*route53.GetGeoLocationOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetGeoLocationWithContext indicates an expected call of GetGeoLocationWithContext func (mr *MockRoute53APIMockRecorder) GetGeoLocationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationWithContext), varargs...) } // GetGeoLocationRequest mocks base method func (m *MockRoute53API) GetGeoLocationRequest(arg0 *route53.GetGeoLocationInput) (*request.Request, *route53.GetGeoLocationOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetGeoLocationRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetGeoLocationOutput) return ret0, ret1 } // GetGeoLocationRequest indicates an expected call of GetGeoLocationRequest func (mr *MockRoute53APIMockRecorder) GetGeoLocationRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGeoLocationRequest", reflect.TypeOf((*MockRoute53API)(nil).GetGeoLocationRequest), arg0) } // GetHealthCheck mocks base method func (m *MockRoute53API) GetHealthCheck(arg0 *route53.GetHealthCheckInput) (*route53.GetHealthCheckOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheck", arg0) ret0, _ := ret[0].(*route53.GetHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheck indicates an expected call of GetHealthCheck func (mr *MockRoute53APIMockRecorder) GetHealthCheck(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheck), arg0) } // GetHealthCheckWithContext mocks base method func (m *MockRoute53API) GetHealthCheckWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckInput, arg2 ...request.Option) (*route53.GetHealthCheckOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHealthCheckWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckWithContext indicates an expected call of GetHealthCheckWithContext func (mr *MockRoute53APIMockRecorder) GetHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckWithContext), varargs...) } // GetHealthCheckRequest mocks base method func (m *MockRoute53API) GetHealthCheckRequest(arg0 *route53.GetHealthCheckInput) (*request.Request, *route53.GetHealthCheckOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHealthCheckOutput) return ret0, ret1 } // GetHealthCheckRequest indicates an expected call of GetHealthCheckRequest func (mr *MockRoute53APIMockRecorder) GetHealthCheckRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckRequest), arg0) } // GetHealthCheckCount mocks base method func (m *MockRoute53API) GetHealthCheckCount(arg0 *route53.GetHealthCheckCountInput) (*route53.GetHealthCheckCountOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckCount", arg0) ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckCount indicates an expected call of GetHealthCheckCount func (mr *MockRoute53APIMockRecorder) GetHealthCheckCount(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCount", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCount), arg0) } // GetHealthCheckCountWithContext mocks base method func (m *MockRoute53API) GetHealthCheckCountWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckCountInput, arg2 ...request.Option) (*route53.GetHealthCheckCountOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHealthCheckCountWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHealthCheckCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckCountWithContext indicates an expected call of GetHealthCheckCountWithContext func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountWithContext), varargs...) } // GetHealthCheckCountRequest mocks base method func (m *MockRoute53API) GetHealthCheckCountRequest(arg0 *route53.GetHealthCheckCountInput) (*request.Request, *route53.GetHealthCheckCountOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckCountRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHealthCheckCountOutput) return ret0, ret1 } // GetHealthCheckCountRequest indicates an expected call of GetHealthCheckCountRequest func (mr *MockRoute53APIMockRecorder) GetHealthCheckCountRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckCountRequest), arg0) } // GetHealthCheckLastFailureReason mocks base method func (m *MockRoute53API) GetHealthCheckLastFailureReason(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*route53.GetHealthCheckLastFailureReasonOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReason", arg0) ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckLastFailureReason indicates an expected call of GetHealthCheckLastFailureReason func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReason(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReason", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReason), arg0) } // GetHealthCheckLastFailureReasonWithContext mocks base method func (m *MockRoute53API) GetHealthCheckLastFailureReasonWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckLastFailureReasonInput, arg2 ...request.Option) (*route53.GetHealthCheckLastFailureReasonOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHealthCheckLastFailureReasonOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckLastFailureReasonWithContext indicates an expected call of GetHealthCheckLastFailureReasonWithContext func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonWithContext), varargs...) } // GetHealthCheckLastFailureReasonRequest mocks base method func (m *MockRoute53API) GetHealthCheckLastFailureReasonRequest(arg0 *route53.GetHealthCheckLastFailureReasonInput) (*request.Request, *route53.GetHealthCheckLastFailureReasonOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckLastFailureReasonRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHealthCheckLastFailureReasonOutput) return ret0, ret1 } // GetHealthCheckLastFailureReasonRequest indicates an expected call of GetHealthCheckLastFailureReasonRequest func (mr *MockRoute53APIMockRecorder) GetHealthCheckLastFailureReasonRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckLastFailureReasonRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckLastFailureReasonRequest), arg0) } // GetHealthCheckStatus mocks base method func (m *MockRoute53API) GetHealthCheckStatus(arg0 *route53.GetHealthCheckStatusInput) (*route53.GetHealthCheckStatusOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckStatus", arg0) ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckStatus indicates an expected call of GetHealthCheckStatus func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatus(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatus", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatus), arg0) } // GetHealthCheckStatusWithContext mocks base method func (m *MockRoute53API) GetHealthCheckStatusWithContext(arg0 aws.Context, arg1 *route53.GetHealthCheckStatusInput, arg2 ...request.Option) (*route53.GetHealthCheckStatusOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHealthCheckStatusWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHealthCheckStatusOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHealthCheckStatusWithContext indicates an expected call of GetHealthCheckStatusWithContext func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusWithContext), varargs...) } // GetHealthCheckStatusRequest mocks base method func (m *MockRoute53API) GetHealthCheckStatusRequest(arg0 *route53.GetHealthCheckStatusInput) (*request.Request, *route53.GetHealthCheckStatusOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHealthCheckStatusRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHealthCheckStatusOutput) return ret0, ret1 } // GetHealthCheckStatusRequest indicates an expected call of GetHealthCheckStatusRequest func (mr *MockRoute53APIMockRecorder) GetHealthCheckStatusRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHealthCheckStatusRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHealthCheckStatusRequest), arg0) } // GetHostedZone mocks base method func (m *MockRoute53API) GetHostedZone(arg0 *route53.GetHostedZoneInput) (*route53.GetHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZone", arg0) ret0, _ := ret[0].(*route53.GetHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZone indicates an expected call of GetHostedZone func (mr *MockRoute53APIMockRecorder) GetHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZone", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZone), arg0) } // GetHostedZoneWithContext mocks base method func (m *MockRoute53API) GetHostedZoneWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneInput, arg2 ...request.Option) (*route53.GetHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZoneWithContext indicates an expected call of GetHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) GetHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneWithContext), varargs...) } // GetHostedZoneRequest mocks base method func (m *MockRoute53API) GetHostedZoneRequest(arg0 *route53.GetHostedZoneInput) (*request.Request, *route53.GetHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHostedZoneOutput) return ret0, ret1 } // GetHostedZoneRequest indicates an expected call of GetHostedZoneRequest func (mr *MockRoute53APIMockRecorder) GetHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneRequest), arg0) } // GetHostedZoneCount mocks base method func (m *MockRoute53API) GetHostedZoneCount(arg0 *route53.GetHostedZoneCountInput) (*route53.GetHostedZoneCountOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZoneCount", arg0) ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZoneCount indicates an expected call of GetHostedZoneCount func (mr *MockRoute53APIMockRecorder) GetHostedZoneCount(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCount", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCount), arg0) } // GetHostedZoneCountWithContext mocks base method func (m *MockRoute53API) GetHostedZoneCountWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneCountInput, arg2 ...request.Option) (*route53.GetHostedZoneCountOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHostedZoneCountWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHostedZoneCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZoneCountWithContext indicates an expected call of GetHostedZoneCountWithContext func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountWithContext), varargs...) } // GetHostedZoneCountRequest mocks base method func (m *MockRoute53API) GetHostedZoneCountRequest(arg0 *route53.GetHostedZoneCountInput) (*request.Request, *route53.GetHostedZoneCountOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZoneCountRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHostedZoneCountOutput) return ret0, ret1 } // GetHostedZoneCountRequest indicates an expected call of GetHostedZoneCountRequest func (mr *MockRoute53APIMockRecorder) GetHostedZoneCountRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneCountRequest), arg0) } // GetHostedZoneLimit mocks base method func (m *MockRoute53API) GetHostedZoneLimit(arg0 *route53.GetHostedZoneLimitInput) (*route53.GetHostedZoneLimitOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZoneLimit", arg0) ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZoneLimit indicates an expected call of GetHostedZoneLimit func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimit(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimit", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimit), arg0) } // GetHostedZoneLimitWithContext mocks base method func (m *MockRoute53API) GetHostedZoneLimitWithContext(arg0 aws.Context, arg1 *route53.GetHostedZoneLimitInput, arg2 ...request.Option) (*route53.GetHostedZoneLimitOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetHostedZoneLimitWithContext", varargs...) ret0, _ := ret[0].(*route53.GetHostedZoneLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetHostedZoneLimitWithContext indicates an expected call of GetHostedZoneLimitWithContext func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitWithContext), varargs...) } // GetHostedZoneLimitRequest mocks base method func (m *MockRoute53API) GetHostedZoneLimitRequest(arg0 *route53.GetHostedZoneLimitInput) (*request.Request, *route53.GetHostedZoneLimitOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetHostedZoneLimitRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetHostedZoneLimitOutput) return ret0, ret1 } // GetHostedZoneLimitRequest indicates an expected call of GetHostedZoneLimitRequest func (mr *MockRoute53APIMockRecorder) GetHostedZoneLimitRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostedZoneLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetHostedZoneLimitRequest), arg0) } // GetQueryLoggingConfig mocks base method func (m *MockRoute53API) GetQueryLoggingConfig(arg0 *route53.GetQueryLoggingConfigInput) (*route53.GetQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetQueryLoggingConfig", arg0) ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetQueryLoggingConfig indicates an expected call of GetQueryLoggingConfig func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfig(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfig", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfig), arg0) } // GetQueryLoggingConfigWithContext mocks base method func (m *MockRoute53API) GetQueryLoggingConfigWithContext(arg0 aws.Context, arg1 *route53.GetQueryLoggingConfigInput, arg2 ...request.Option) (*route53.GetQueryLoggingConfigOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetQueryLoggingConfigWithContext", varargs...) ret0, _ := ret[0].(*route53.GetQueryLoggingConfigOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetQueryLoggingConfigWithContext indicates an expected call of GetQueryLoggingConfigWithContext func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigWithContext), varargs...) } // GetQueryLoggingConfigRequest mocks base method func (m *MockRoute53API) GetQueryLoggingConfigRequest(arg0 *route53.GetQueryLoggingConfigInput) (*request.Request, *route53.GetQueryLoggingConfigOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetQueryLoggingConfigRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetQueryLoggingConfigOutput) return ret0, ret1 } // GetQueryLoggingConfigRequest indicates an expected call of GetQueryLoggingConfigRequest func (mr *MockRoute53APIMockRecorder) GetQueryLoggingConfigRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryLoggingConfigRequest", reflect.TypeOf((*MockRoute53API)(nil).GetQueryLoggingConfigRequest), arg0) } // GetReusableDelegationSet mocks base method func (m *MockRoute53API) GetReusableDelegationSet(arg0 *route53.GetReusableDelegationSetInput) (*route53.GetReusableDelegationSetOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReusableDelegationSet", arg0) ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetReusableDelegationSet indicates an expected call of GetReusableDelegationSet func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSet(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSet", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSet), arg0) } // GetReusableDelegationSetWithContext mocks base method func (m *MockRoute53API) GetReusableDelegationSetWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetReusableDelegationSetWithContext", varargs...) ret0, _ := ret[0].(*route53.GetReusableDelegationSetOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetReusableDelegationSetWithContext indicates an expected call of GetReusableDelegationSetWithContext func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetWithContext), varargs...) } // GetReusableDelegationSetRequest mocks base method func (m *MockRoute53API) GetReusableDelegationSetRequest(arg0 *route53.GetReusableDelegationSetInput) (*request.Request, *route53.GetReusableDelegationSetOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReusableDelegationSetRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetReusableDelegationSetOutput) return ret0, ret1 } // GetReusableDelegationSetRequest indicates an expected call of GetReusableDelegationSetRequest func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetRequest), arg0) } // GetReusableDelegationSetLimit mocks base method func (m *MockRoute53API) GetReusableDelegationSetLimit(arg0 *route53.GetReusableDelegationSetLimitInput) (*route53.GetReusableDelegationSetLimitOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReusableDelegationSetLimit", arg0) ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetReusableDelegationSetLimit indicates an expected call of GetReusableDelegationSetLimit func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimit(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimit", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimit), arg0) } // GetReusableDelegationSetLimitWithContext mocks base method func (m *MockRoute53API) GetReusableDelegationSetLimitWithContext(arg0 aws.Context, arg1 *route53.GetReusableDelegationSetLimitInput, arg2 ...request.Option) (*route53.GetReusableDelegationSetLimitOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitWithContext", varargs...) ret0, _ := ret[0].(*route53.GetReusableDelegationSetLimitOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetReusableDelegationSetLimitWithContext indicates an expected call of GetReusableDelegationSetLimitWithContext func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitWithContext), varargs...) } // GetReusableDelegationSetLimitRequest mocks base method func (m *MockRoute53API) GetReusableDelegationSetLimitRequest(arg0 *route53.GetReusableDelegationSetLimitInput) (*request.Request, *route53.GetReusableDelegationSetLimitOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetReusableDelegationSetLimitRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetReusableDelegationSetLimitOutput) return ret0, ret1 } // GetReusableDelegationSetLimitRequest indicates an expected call of GetReusableDelegationSetLimitRequest func (mr *MockRoute53APIMockRecorder) GetReusableDelegationSetLimitRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReusableDelegationSetLimitRequest", reflect.TypeOf((*MockRoute53API)(nil).GetReusableDelegationSetLimitRequest), arg0) } // GetTrafficPolicy mocks base method func (m *MockRoute53API) GetTrafficPolicy(arg0 *route53.GetTrafficPolicyInput) (*route53.GetTrafficPolicyOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicy", arg0) ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicy indicates an expected call of GetTrafficPolicy func (mr *MockRoute53APIMockRecorder) GetTrafficPolicy(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicy", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicy), arg0) } // GetTrafficPolicyWithContext mocks base method func (m *MockRoute53API) GetTrafficPolicyWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInput, arg2 ...request.Option) (*route53.GetTrafficPolicyOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTrafficPolicyWithContext", varargs...) ret0, _ := ret[0].(*route53.GetTrafficPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicyWithContext indicates an expected call of GetTrafficPolicyWithContext func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyWithContext), varargs...) } // GetTrafficPolicyRequest mocks base method func (m *MockRoute53API) GetTrafficPolicyRequest(arg0 *route53.GetTrafficPolicyInput) (*request.Request, *route53.GetTrafficPolicyOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicyRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetTrafficPolicyOutput) return ret0, ret1 } // GetTrafficPolicyRequest indicates an expected call of GetTrafficPolicyRequest func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyRequest), arg0) } // GetTrafficPolicyInstance mocks base method func (m *MockRoute53API) GetTrafficPolicyInstance(arg0 *route53.GetTrafficPolicyInstanceInput) (*route53.GetTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicyInstance", arg0) ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicyInstance indicates an expected call of GetTrafficPolicyInstance func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstance), arg0) } // GetTrafficPolicyInstanceWithContext mocks base method func (m *MockRoute53API) GetTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceWithContext", varargs...) ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicyInstanceWithContext indicates an expected call of GetTrafficPolicyInstanceWithContext func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceWithContext), varargs...) } // GetTrafficPolicyInstanceRequest mocks base method func (m *MockRoute53API) GetTrafficPolicyInstanceRequest(arg0 *route53.GetTrafficPolicyInstanceInput) (*request.Request, *route53.GetTrafficPolicyInstanceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceOutput) return ret0, ret1 } // GetTrafficPolicyInstanceRequest indicates an expected call of GetTrafficPolicyInstanceRequest func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceRequest), arg0) } // GetTrafficPolicyInstanceCount mocks base method func (m *MockRoute53API) GetTrafficPolicyInstanceCount(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*route53.GetTrafficPolicyInstanceCountOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCount", arg0) ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicyInstanceCount indicates an expected call of GetTrafficPolicyInstanceCount func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCount(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCount", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCount), arg0) } // GetTrafficPolicyInstanceCountWithContext mocks base method func (m *MockRoute53API) GetTrafficPolicyInstanceCountWithContext(arg0 aws.Context, arg1 *route53.GetTrafficPolicyInstanceCountInput, arg2 ...request.Option) (*route53.GetTrafficPolicyInstanceCountOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountWithContext", varargs...) ret0, _ := ret[0].(*route53.GetTrafficPolicyInstanceCountOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // GetTrafficPolicyInstanceCountWithContext indicates an expected call of GetTrafficPolicyInstanceCountWithContext func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountWithContext", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountWithContext), varargs...) } // GetTrafficPolicyInstanceCountRequest mocks base method func (m *MockRoute53API) GetTrafficPolicyInstanceCountRequest(arg0 *route53.GetTrafficPolicyInstanceCountInput) (*request.Request, *route53.GetTrafficPolicyInstanceCountOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "GetTrafficPolicyInstanceCountRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.GetTrafficPolicyInstanceCountOutput) return ret0, ret1 } // GetTrafficPolicyInstanceCountRequest indicates an expected call of GetTrafficPolicyInstanceCountRequest func (mr *MockRoute53APIMockRecorder) GetTrafficPolicyInstanceCountRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTrafficPolicyInstanceCountRequest", reflect.TypeOf((*MockRoute53API)(nil).GetTrafficPolicyInstanceCountRequest), arg0) } // ListGeoLocations mocks base method func (m *MockRoute53API) ListGeoLocations(arg0 *route53.ListGeoLocationsInput) (*route53.ListGeoLocationsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListGeoLocations", arg0) ret0, _ := ret[0].(*route53.ListGeoLocationsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListGeoLocations indicates an expected call of ListGeoLocations func (mr *MockRoute53APIMockRecorder) ListGeoLocations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocations", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocations), arg0) } // ListGeoLocationsWithContext mocks base method func (m *MockRoute53API) ListGeoLocationsWithContext(arg0 aws.Context, arg1 *route53.ListGeoLocationsInput, arg2 ...request.Option) (*route53.ListGeoLocationsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListGeoLocationsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListGeoLocationsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListGeoLocationsWithContext indicates an expected call of ListGeoLocationsWithContext func (mr *MockRoute53APIMockRecorder) ListGeoLocationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsWithContext), varargs...) } // ListGeoLocationsRequest mocks base method func (m *MockRoute53API) ListGeoLocationsRequest(arg0 *route53.ListGeoLocationsInput) (*request.Request, *route53.ListGeoLocationsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListGeoLocationsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListGeoLocationsOutput) return ret0, ret1 } // ListGeoLocationsRequest indicates an expected call of ListGeoLocationsRequest func (mr *MockRoute53APIMockRecorder) ListGeoLocationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGeoLocationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListGeoLocationsRequest), arg0) } // ListHealthChecks mocks base method func (m *MockRoute53API) ListHealthChecks(arg0 *route53.ListHealthChecksInput) (*route53.ListHealthChecksOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHealthChecks", arg0) ret0, _ := ret[0].(*route53.ListHealthChecksOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHealthChecks indicates an expected call of ListHealthChecks func (mr *MockRoute53APIMockRecorder) ListHealthChecks(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecks", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecks), arg0) } // ListHealthChecksWithContext mocks base method func (m *MockRoute53API) ListHealthChecksWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 ...request.Option) (*route53.ListHealthChecksOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListHealthChecksWithContext", varargs...) ret0, _ := ret[0].(*route53.ListHealthChecksOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHealthChecksWithContext indicates an expected call of ListHealthChecksWithContext func (mr *MockRoute53APIMockRecorder) ListHealthChecksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksWithContext), varargs...) } // ListHealthChecksRequest mocks base method func (m *MockRoute53API) ListHealthChecksRequest(arg0 *route53.ListHealthChecksInput) (*request.Request, *route53.ListHealthChecksOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHealthChecksRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListHealthChecksOutput) return ret0, ret1 } // ListHealthChecksRequest indicates an expected call of ListHealthChecksRequest func (mr *MockRoute53APIMockRecorder) ListHealthChecksRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksRequest), arg0) } // ListHealthChecksPages mocks base method func (m *MockRoute53API) ListHealthChecksPages(arg0 *route53.ListHealthChecksInput, arg1 func(*route53.ListHealthChecksOutput, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHealthChecksPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ListHealthChecksPages indicates an expected call of ListHealthChecksPages func (mr *MockRoute53APIMockRecorder) ListHealthChecksPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHealthChecksPages", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPages), arg0, arg1) } // ListHealthChecksPagesWithContext mocks base method func (m *MockRoute53API) ListHealthChecksPagesWithContext(arg0 aws.Context, arg1 *route53.ListHealthChecksInput, arg2 func(*route53.ListHealthChecksOutput, 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, "ListHealthChecksPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ListHealthChecksPagesWithContext indicates an expected call of ListHealthChecksPagesWithContext func (mr *MockRoute53APIMockRecorder) ListHealthChecksPagesWithContext(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, "ListHealthChecksPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHealthChecksPagesWithContext), varargs...) } // ListHostedZones mocks base method func (m *MockRoute53API) ListHostedZones(arg0 *route53.ListHostedZonesInput) (*route53.ListHostedZonesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZones", arg0) ret0, _ := ret[0].(*route53.ListHostedZonesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHostedZones indicates an expected call of ListHostedZones func (mr *MockRoute53APIMockRecorder) ListHostedZones(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZones", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZones), arg0) } // ListHostedZonesWithContext mocks base method func (m *MockRoute53API) ListHostedZonesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 ...request.Option) (*route53.ListHostedZonesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListHostedZonesWithContext", varargs...) ret0, _ := ret[0].(*route53.ListHostedZonesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHostedZonesWithContext indicates an expected call of ListHostedZonesWithContext func (mr *MockRoute53APIMockRecorder) ListHostedZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesWithContext), varargs...) } // ListHostedZonesRequest mocks base method func (m *MockRoute53API) ListHostedZonesRequest(arg0 *route53.ListHostedZonesInput) (*request.Request, *route53.ListHostedZonesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZonesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListHostedZonesOutput) return ret0, ret1 } // ListHostedZonesRequest indicates an expected call of ListHostedZonesRequest func (mr *MockRoute53APIMockRecorder) ListHostedZonesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesRequest), arg0) } // ListHostedZonesPages mocks base method func (m *MockRoute53API) ListHostedZonesPages(arg0 *route53.ListHostedZonesInput, arg1 func(*route53.ListHostedZonesOutput, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZonesPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ListHostedZonesPages indicates an expected call of ListHostedZonesPages func (mr *MockRoute53APIMockRecorder) ListHostedZonesPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesPages", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPages), arg0, arg1) } // ListHostedZonesPagesWithContext mocks base method func (m *MockRoute53API) ListHostedZonesPagesWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesInput, arg2 func(*route53.ListHostedZonesOutput, 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, "ListHostedZonesPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ListHostedZonesPagesWithContext indicates an expected call of ListHostedZonesPagesWithContext func (mr *MockRoute53APIMockRecorder) ListHostedZonesPagesWithContext(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, "ListHostedZonesPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesPagesWithContext), varargs...) } // ListHostedZonesByName mocks base method func (m *MockRoute53API) ListHostedZonesByName(arg0 *route53.ListHostedZonesByNameInput) (*route53.ListHostedZonesByNameOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZonesByName", arg0) ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHostedZonesByName indicates an expected call of ListHostedZonesByName func (mr *MockRoute53APIMockRecorder) ListHostedZonesByName(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByName", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByName), arg0) } // ListHostedZonesByNameWithContext mocks base method func (m *MockRoute53API) ListHostedZonesByNameWithContext(arg0 aws.Context, arg1 *route53.ListHostedZonesByNameInput, arg2 ...request.Option) (*route53.ListHostedZonesByNameOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListHostedZonesByNameWithContext", varargs...) ret0, _ := ret[0].(*route53.ListHostedZonesByNameOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListHostedZonesByNameWithContext indicates an expected call of ListHostedZonesByNameWithContext func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameWithContext), varargs...) } // ListHostedZonesByNameRequest mocks base method func (m *MockRoute53API) ListHostedZonesByNameRequest(arg0 *route53.ListHostedZonesByNameInput) (*request.Request, *route53.ListHostedZonesByNameOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListHostedZonesByNameRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListHostedZonesByNameOutput) return ret0, ret1 } // ListHostedZonesByNameRequest indicates an expected call of ListHostedZonesByNameRequest func (mr *MockRoute53APIMockRecorder) ListHostedZonesByNameRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListHostedZonesByNameRequest", reflect.TypeOf((*MockRoute53API)(nil).ListHostedZonesByNameRequest), arg0) } // ListQueryLoggingConfigs mocks base method func (m *MockRoute53API) ListQueryLoggingConfigs(arg0 *route53.ListQueryLoggingConfigsInput) (*route53.ListQueryLoggingConfigsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListQueryLoggingConfigs", arg0) ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListQueryLoggingConfigs indicates an expected call of ListQueryLoggingConfigs func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigs(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigs", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigs), arg0) } // ListQueryLoggingConfigsWithContext mocks base method func (m *MockRoute53API) ListQueryLoggingConfigsWithContext(arg0 aws.Context, arg1 *route53.ListQueryLoggingConfigsInput, arg2 ...request.Option) (*route53.ListQueryLoggingConfigsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListQueryLoggingConfigsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListQueryLoggingConfigsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListQueryLoggingConfigsWithContext indicates an expected call of ListQueryLoggingConfigsWithContext func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsWithContext), varargs...) } // ListQueryLoggingConfigsRequest mocks base method func (m *MockRoute53API) ListQueryLoggingConfigsRequest(arg0 *route53.ListQueryLoggingConfigsInput) (*request.Request, *route53.ListQueryLoggingConfigsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListQueryLoggingConfigsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListQueryLoggingConfigsOutput) return ret0, ret1 } // ListQueryLoggingConfigsRequest indicates an expected call of ListQueryLoggingConfigsRequest func (mr *MockRoute53APIMockRecorder) ListQueryLoggingConfigsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListQueryLoggingConfigsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListQueryLoggingConfigsRequest), arg0) } // ListResourceRecordSets mocks base method func (m *MockRoute53API) ListResourceRecordSets(arg0 *route53.ListResourceRecordSetsInput) (*route53.ListResourceRecordSetsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListResourceRecordSets", arg0) ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListResourceRecordSets indicates an expected call of ListResourceRecordSets func (mr *MockRoute53APIMockRecorder) ListResourceRecordSets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSets", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSets), arg0) } // ListResourceRecordSetsWithContext mocks base method func (m *MockRoute53API) ListResourceRecordSetsWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 ...request.Option) (*route53.ListResourceRecordSetsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListResourceRecordSetsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListResourceRecordSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListResourceRecordSetsWithContext indicates an expected call of ListResourceRecordSetsWithContext func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsWithContext), varargs...) } // ListResourceRecordSetsRequest mocks base method func (m *MockRoute53API) ListResourceRecordSetsRequest(arg0 *route53.ListResourceRecordSetsInput) (*request.Request, *route53.ListResourceRecordSetsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListResourceRecordSetsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListResourceRecordSetsOutput) return ret0, ret1 } // ListResourceRecordSetsRequest indicates an expected call of ListResourceRecordSetsRequest func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsRequest), arg0) } // ListResourceRecordSetsPages mocks base method func (m *MockRoute53API) ListResourceRecordSetsPages(arg0 *route53.ListResourceRecordSetsInput, arg1 func(*route53.ListResourceRecordSetsOutput, bool) bool) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListResourceRecordSetsPages", arg0, arg1) ret0, _ := ret[0].(error) return ret0 } // ListResourceRecordSetsPages indicates an expected call of ListResourceRecordSetsPages func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPages(arg0, arg1 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceRecordSetsPages", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPages), arg0, arg1) } // ListResourceRecordSetsPagesWithContext mocks base method func (m *MockRoute53API) ListResourceRecordSetsPagesWithContext(arg0 aws.Context, arg1 *route53.ListResourceRecordSetsInput, arg2 func(*route53.ListResourceRecordSetsOutput, 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, "ListResourceRecordSetsPagesWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // ListResourceRecordSetsPagesWithContext indicates an expected call of ListResourceRecordSetsPagesWithContext func (mr *MockRoute53APIMockRecorder) ListResourceRecordSetsPagesWithContext(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, "ListResourceRecordSetsPagesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListResourceRecordSetsPagesWithContext), varargs...) } // ListReusableDelegationSets mocks base method func (m *MockRoute53API) ListReusableDelegationSets(arg0 *route53.ListReusableDelegationSetsInput) (*route53.ListReusableDelegationSetsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListReusableDelegationSets", arg0) ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListReusableDelegationSets indicates an expected call of ListReusableDelegationSets func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSets(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSets", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSets), arg0) } // ListReusableDelegationSetsWithContext mocks base method func (m *MockRoute53API) ListReusableDelegationSetsWithContext(arg0 aws.Context, arg1 *route53.ListReusableDelegationSetsInput, arg2 ...request.Option) (*route53.ListReusableDelegationSetsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListReusableDelegationSetsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListReusableDelegationSetsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListReusableDelegationSetsWithContext indicates an expected call of ListReusableDelegationSetsWithContext func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsWithContext), varargs...) } // ListReusableDelegationSetsRequest mocks base method func (m *MockRoute53API) ListReusableDelegationSetsRequest(arg0 *route53.ListReusableDelegationSetsInput) (*request.Request, *route53.ListReusableDelegationSetsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListReusableDelegationSetsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListReusableDelegationSetsOutput) return ret0, ret1 } // ListReusableDelegationSetsRequest indicates an expected call of ListReusableDelegationSetsRequest func (mr *MockRoute53APIMockRecorder) ListReusableDelegationSetsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReusableDelegationSetsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListReusableDelegationSetsRequest), arg0) } // ListTagsForResource mocks base method func (m *MockRoute53API) ListTagsForResource(arg0 *route53.ListTagsForResourceInput) (*route53.ListTagsForResourceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForResource", arg0) ret0, _ := ret[0].(*route53.ListTagsForResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForResource indicates an expected call of ListTagsForResource func (mr *MockRoute53APIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResource), arg0) } // ListTagsForResourceWithContext mocks base method func (m *MockRoute53API) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourceInput, arg2 ...request.Option) (*route53.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].(*route53.ListTagsForResourceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext func (mr *MockRoute53APIMockRecorder) 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((*MockRoute53API)(nil).ListTagsForResourceWithContext), varargs...) } // ListTagsForResourceRequest mocks base method func (m *MockRoute53API) ListTagsForResourceRequest(arg0 *route53.ListTagsForResourceInput) (*request.Request, *route53.ListTagsForResourceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTagsForResourceOutput) return ret0, ret1 } // ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest func (mr *MockRoute53APIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourceRequest), arg0) } // ListTagsForResources mocks base method func (m *MockRoute53API) ListTagsForResources(arg0 *route53.ListTagsForResourcesInput) (*route53.ListTagsForResourcesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForResources", arg0) ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForResources indicates an expected call of ListTagsForResources func (mr *MockRoute53APIMockRecorder) ListTagsForResources(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResources", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResources), arg0) } // ListTagsForResourcesWithContext mocks base method func (m *MockRoute53API) ListTagsForResourcesWithContext(arg0 aws.Context, arg1 *route53.ListTagsForResourcesInput, arg2 ...request.Option) (*route53.ListTagsForResourcesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTagsForResourcesWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTagsForResourcesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTagsForResourcesWithContext indicates an expected call of ListTagsForResourcesWithContext func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesWithContext), varargs...) } // ListTagsForResourcesRequest mocks base method func (m *MockRoute53API) ListTagsForResourcesRequest(arg0 *route53.ListTagsForResourcesInput) (*request.Request, *route53.ListTagsForResourcesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTagsForResourcesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTagsForResourcesOutput) return ret0, ret1 } // ListTagsForResourcesRequest indicates an expected call of ListTagsForResourcesRequest func (mr *MockRoute53APIMockRecorder) ListTagsForResourcesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourcesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTagsForResourcesRequest), arg0) } // ListTrafficPolicies mocks base method func (m *MockRoute53API) ListTrafficPolicies(arg0 *route53.ListTrafficPoliciesInput) (*route53.ListTrafficPoliciesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicies", arg0) ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicies indicates an expected call of ListTrafficPolicies func (mr *MockRoute53APIMockRecorder) ListTrafficPolicies(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicies", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicies), arg0) } // ListTrafficPoliciesWithContext mocks base method func (m *MockRoute53API) ListTrafficPoliciesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPoliciesInput, arg2 ...request.Option) (*route53.ListTrafficPoliciesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTrafficPoliciesWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTrafficPoliciesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPoliciesWithContext indicates an expected call of ListTrafficPoliciesWithContext func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesWithContext), varargs...) } // ListTrafficPoliciesRequest mocks base method func (m *MockRoute53API) ListTrafficPoliciesRequest(arg0 *route53.ListTrafficPoliciesInput) (*request.Request, *route53.ListTrafficPoliciesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPoliciesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTrafficPoliciesOutput) return ret0, ret1 } // ListTrafficPoliciesRequest indicates an expected call of ListTrafficPoliciesRequest func (mr *MockRoute53APIMockRecorder) ListTrafficPoliciesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPoliciesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPoliciesRequest), arg0) } // ListTrafficPolicyInstances mocks base method func (m *MockRoute53API) ListTrafficPolicyInstances(arg0 *route53.ListTrafficPolicyInstancesInput) (*route53.ListTrafficPolicyInstancesOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstances", arg0) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstances indicates an expected call of ListTrafficPolicyInstances func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstances(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstances", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstances), arg0) } // ListTrafficPolicyInstancesWithContext mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstancesWithContext indicates an expected call of ListTrafficPolicyInstancesWithContext func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesWithContext), varargs...) } // ListTrafficPolicyInstancesRequest mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesRequest(arg0 *route53.ListTrafficPolicyInstancesInput) (*request.Request, *route53.ListTrafficPolicyInstancesOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesOutput) return ret0, ret1 } // ListTrafficPolicyInstancesRequest indicates an expected call of ListTrafficPolicyInstancesRequest func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesRequest), arg0) } // ListTrafficPolicyInstancesByHostedZone mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZone(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZone", arg0) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstancesByHostedZone indicates an expected call of ListTrafficPolicyInstancesByHostedZone func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZone(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZone", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZone), arg0) } // ListTrafficPolicyInstancesByHostedZoneWithContext mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByHostedZoneInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByHostedZoneOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstancesByHostedZoneWithContext indicates an expected call of ListTrafficPolicyInstancesByHostedZoneWithContext func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneWithContext), varargs...) } // ListTrafficPolicyInstancesByHostedZoneRequest mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 *route53.ListTrafficPolicyInstancesByHostedZoneInput) (*request.Request, *route53.ListTrafficPolicyInstancesByHostedZoneOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByHostedZoneRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByHostedZoneOutput) return ret0, ret1 } // ListTrafficPolicyInstancesByHostedZoneRequest indicates an expected call of ListTrafficPolicyInstancesByHostedZoneRequest func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByHostedZoneRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByHostedZoneRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByHostedZoneRequest), arg0) } // ListTrafficPolicyInstancesByPolicy mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicy(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicy", arg0) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstancesByPolicy indicates an expected call of ListTrafficPolicyInstancesByPolicy func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicy(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicy", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicy), arg0) } // ListTrafficPolicyInstancesByPolicyWithContext mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyInstancesByPolicyInput, arg2 ...request.Option) (*route53.ListTrafficPolicyInstancesByPolicyOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTrafficPolicyInstancesByPolicyOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyInstancesByPolicyWithContext indicates an expected call of ListTrafficPolicyInstancesByPolicyWithContext func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyWithContext), varargs...) } // ListTrafficPolicyInstancesByPolicyRequest mocks base method func (m *MockRoute53API) ListTrafficPolicyInstancesByPolicyRequest(arg0 *route53.ListTrafficPolicyInstancesByPolicyInput) (*request.Request, *route53.ListTrafficPolicyInstancesByPolicyOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyInstancesByPolicyRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTrafficPolicyInstancesByPolicyOutput) return ret0, ret1 } // ListTrafficPolicyInstancesByPolicyRequest indicates an expected call of ListTrafficPolicyInstancesByPolicyRequest func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyInstancesByPolicyRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyInstancesByPolicyRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyInstancesByPolicyRequest), arg0) } // ListTrafficPolicyVersions mocks base method func (m *MockRoute53API) ListTrafficPolicyVersions(arg0 *route53.ListTrafficPolicyVersionsInput) (*route53.ListTrafficPolicyVersionsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyVersions", arg0) ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyVersions indicates an expected call of ListTrafficPolicyVersions func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersions(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersions", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersions), arg0) } // ListTrafficPolicyVersionsWithContext mocks base method func (m *MockRoute53API) ListTrafficPolicyVersionsWithContext(arg0 aws.Context, arg1 *route53.ListTrafficPolicyVersionsInput, arg2 ...request.Option) (*route53.ListTrafficPolicyVersionsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListTrafficPolicyVersionsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListTrafficPolicyVersionsWithContext indicates an expected call of ListTrafficPolicyVersionsWithContext func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsWithContext), varargs...) } // ListTrafficPolicyVersionsRequest mocks base method func (m *MockRoute53API) ListTrafficPolicyVersionsRequest(arg0 *route53.ListTrafficPolicyVersionsInput) (*request.Request, *route53.ListTrafficPolicyVersionsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListTrafficPolicyVersionsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListTrafficPolicyVersionsOutput) return ret0, ret1 } // ListTrafficPolicyVersionsRequest indicates an expected call of ListTrafficPolicyVersionsRequest func (mr *MockRoute53APIMockRecorder) ListTrafficPolicyVersionsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTrafficPolicyVersionsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListTrafficPolicyVersionsRequest), arg0) } // ListVPCAssociationAuthorizations mocks base method func (m *MockRoute53API) ListVPCAssociationAuthorizations(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*route53.ListVPCAssociationAuthorizationsOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizations", arg0) ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListVPCAssociationAuthorizations indicates an expected call of ListVPCAssociationAuthorizations func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizations(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizations", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizations), arg0) } // ListVPCAssociationAuthorizationsWithContext mocks base method func (m *MockRoute53API) ListVPCAssociationAuthorizationsWithContext(arg0 aws.Context, arg1 *route53.ListVPCAssociationAuthorizationsInput, arg2 ...request.Option) (*route53.ListVPCAssociationAuthorizationsOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsWithContext", varargs...) ret0, _ := ret[0].(*route53.ListVPCAssociationAuthorizationsOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // ListVPCAssociationAuthorizationsWithContext indicates an expected call of ListVPCAssociationAuthorizationsWithContext func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsWithContext", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsWithContext), varargs...) } // ListVPCAssociationAuthorizationsRequest mocks base method func (m *MockRoute53API) ListVPCAssociationAuthorizationsRequest(arg0 *route53.ListVPCAssociationAuthorizationsInput) (*request.Request, *route53.ListVPCAssociationAuthorizationsOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ListVPCAssociationAuthorizationsRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.ListVPCAssociationAuthorizationsOutput) return ret0, ret1 } // ListVPCAssociationAuthorizationsRequest indicates an expected call of ListVPCAssociationAuthorizationsRequest func (mr *MockRoute53APIMockRecorder) ListVPCAssociationAuthorizationsRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVPCAssociationAuthorizationsRequest", reflect.TypeOf((*MockRoute53API)(nil).ListVPCAssociationAuthorizationsRequest), arg0) } // TestDNSAnswer mocks base method func (m *MockRoute53API) TestDNSAnswer(arg0 *route53.TestDNSAnswerInput) (*route53.TestDNSAnswerOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TestDNSAnswer", arg0) ret0, _ := ret[0].(*route53.TestDNSAnswerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // TestDNSAnswer indicates an expected call of TestDNSAnswer func (mr *MockRoute53APIMockRecorder) TestDNSAnswer(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswer", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswer), arg0) } // TestDNSAnswerWithContext mocks base method func (m *MockRoute53API) TestDNSAnswerWithContext(arg0 aws.Context, arg1 *route53.TestDNSAnswerInput, arg2 ...request.Option) (*route53.TestDNSAnswerOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "TestDNSAnswerWithContext", varargs...) ret0, _ := ret[0].(*route53.TestDNSAnswerOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // TestDNSAnswerWithContext indicates an expected call of TestDNSAnswerWithContext func (mr *MockRoute53APIMockRecorder) TestDNSAnswerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerWithContext", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerWithContext), varargs...) } // TestDNSAnswerRequest mocks base method func (m *MockRoute53API) TestDNSAnswerRequest(arg0 *route53.TestDNSAnswerInput) (*request.Request, *route53.TestDNSAnswerOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "TestDNSAnswerRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.TestDNSAnswerOutput) return ret0, ret1 } // TestDNSAnswerRequest indicates an expected call of TestDNSAnswerRequest func (mr *MockRoute53APIMockRecorder) TestDNSAnswerRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestDNSAnswerRequest", reflect.TypeOf((*MockRoute53API)(nil).TestDNSAnswerRequest), arg0) } // UpdateHealthCheck mocks base method func (m *MockRoute53API) UpdateHealthCheck(arg0 *route53.UpdateHealthCheckInput) (*route53.UpdateHealthCheckOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateHealthCheck", arg0) ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateHealthCheck indicates an expected call of UpdateHealthCheck func (mr *MockRoute53APIMockRecorder) UpdateHealthCheck(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheck", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheck), arg0) } // UpdateHealthCheckWithContext mocks base method func (m *MockRoute53API) UpdateHealthCheckWithContext(arg0 aws.Context, arg1 *route53.UpdateHealthCheckInput, arg2 ...request.Option) (*route53.UpdateHealthCheckOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateHealthCheckWithContext", varargs...) ret0, _ := ret[0].(*route53.UpdateHealthCheckOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateHealthCheckWithContext indicates an expected call of UpdateHealthCheckWithContext func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckWithContext), varargs...) } // UpdateHealthCheckRequest mocks base method func (m *MockRoute53API) UpdateHealthCheckRequest(arg0 *route53.UpdateHealthCheckInput) (*request.Request, *route53.UpdateHealthCheckOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateHealthCheckRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.UpdateHealthCheckOutput) return ret0, ret1 } // UpdateHealthCheckRequest indicates an expected call of UpdateHealthCheckRequest func (mr *MockRoute53APIMockRecorder) UpdateHealthCheckRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHealthCheckRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHealthCheckRequest), arg0) } // UpdateHostedZoneComment mocks base method func (m *MockRoute53API) UpdateHostedZoneComment(arg0 *route53.UpdateHostedZoneCommentInput) (*route53.UpdateHostedZoneCommentOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateHostedZoneComment", arg0) ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateHostedZoneComment indicates an expected call of UpdateHostedZoneComment func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneComment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneComment), arg0) } // UpdateHostedZoneCommentWithContext mocks base method func (m *MockRoute53API) UpdateHostedZoneCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateHostedZoneCommentInput, arg2 ...request.Option) (*route53.UpdateHostedZoneCommentOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateHostedZoneCommentWithContext", varargs...) ret0, _ := ret[0].(*route53.UpdateHostedZoneCommentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateHostedZoneCommentWithContext indicates an expected call of UpdateHostedZoneCommentWithContext func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentWithContext), varargs...) } // UpdateHostedZoneCommentRequest mocks base method func (m *MockRoute53API) UpdateHostedZoneCommentRequest(arg0 *route53.UpdateHostedZoneCommentInput) (*request.Request, *route53.UpdateHostedZoneCommentOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateHostedZoneCommentRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.UpdateHostedZoneCommentOutput) return ret0, ret1 } // UpdateHostedZoneCommentRequest indicates an expected call of UpdateHostedZoneCommentRequest func (mr *MockRoute53APIMockRecorder) UpdateHostedZoneCommentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateHostedZoneCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateHostedZoneCommentRequest), arg0) } // UpdateTrafficPolicyComment mocks base method func (m *MockRoute53API) UpdateTrafficPolicyComment(arg0 *route53.UpdateTrafficPolicyCommentInput) (*route53.UpdateTrafficPolicyCommentOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateTrafficPolicyComment", arg0) ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTrafficPolicyComment indicates an expected call of UpdateTrafficPolicyComment func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyComment(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyComment", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyComment), arg0) } // UpdateTrafficPolicyCommentWithContext mocks base method func (m *MockRoute53API) UpdateTrafficPolicyCommentWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyCommentInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyCommentOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentWithContext", varargs...) ret0, _ := ret[0].(*route53.UpdateTrafficPolicyCommentOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTrafficPolicyCommentWithContext indicates an expected call of UpdateTrafficPolicyCommentWithContext func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentWithContext), varargs...) } // UpdateTrafficPolicyCommentRequest mocks base method func (m *MockRoute53API) UpdateTrafficPolicyCommentRequest(arg0 *route53.UpdateTrafficPolicyCommentInput) (*request.Request, *route53.UpdateTrafficPolicyCommentOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateTrafficPolicyCommentRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.UpdateTrafficPolicyCommentOutput) return ret0, ret1 } // UpdateTrafficPolicyCommentRequest indicates an expected call of UpdateTrafficPolicyCommentRequest func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyCommentRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyCommentRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyCommentRequest), arg0) } // UpdateTrafficPolicyInstance mocks base method func (m *MockRoute53API) UpdateTrafficPolicyInstance(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*route53.UpdateTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstance", arg0) ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTrafficPolicyInstance indicates an expected call of UpdateTrafficPolicyInstance func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstance(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstance", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstance), arg0) } // UpdateTrafficPolicyInstanceWithContext mocks base method func (m *MockRoute53API) UpdateTrafficPolicyInstanceWithContext(arg0 aws.Context, arg1 *route53.UpdateTrafficPolicyInstanceInput, arg2 ...request.Option) (*route53.UpdateTrafficPolicyInstanceOutput, error) { m.ctrl.T.Helper() varargs := []interface{}{arg0, arg1} for _, a := range arg2 { varargs = append(varargs, a) } ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceWithContext", varargs...) ret0, _ := ret[0].(*route53.UpdateTrafficPolicyInstanceOutput) ret1, _ := ret[1].(error) return ret0, ret1 } // UpdateTrafficPolicyInstanceWithContext indicates an expected call of UpdateTrafficPolicyInstanceWithContext func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceWithContext", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceWithContext), varargs...) } // UpdateTrafficPolicyInstanceRequest mocks base method func (m *MockRoute53API) UpdateTrafficPolicyInstanceRequest(arg0 *route53.UpdateTrafficPolicyInstanceInput) (*request.Request, *route53.UpdateTrafficPolicyInstanceOutput) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "UpdateTrafficPolicyInstanceRequest", arg0) ret0, _ := ret[0].(*request.Request) ret1, _ := ret[1].(*route53.UpdateTrafficPolicyInstanceOutput) return ret0, ret1 } // UpdateTrafficPolicyInstanceRequest indicates an expected call of UpdateTrafficPolicyInstanceRequest func (mr *MockRoute53APIMockRecorder) UpdateTrafficPolicyInstanceRequest(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTrafficPolicyInstanceRequest", reflect.TypeOf((*MockRoute53API)(nil).UpdateTrafficPolicyInstanceRequest), arg0) } // WaitUntilResourceRecordSetsChanged mocks base method func (m *MockRoute53API) WaitUntilResourceRecordSetsChanged(arg0 *route53.GetChangeInput) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WaitUntilResourceRecordSetsChanged", arg0) ret0, _ := ret[0].(error) return ret0 } // WaitUntilResourceRecordSetsChanged indicates an expected call of WaitUntilResourceRecordSetsChanged func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChanged(arg0 interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChanged", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChanged), arg0) } // WaitUntilResourceRecordSetsChangedWithContext mocks base method func (m *MockRoute53API) WaitUntilResourceRecordSetsChangedWithContext(arg0 aws.Context, arg1 *route53.GetChangeInput, 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, "WaitUntilResourceRecordSetsChangedWithContext", varargs...) ret0, _ := ret[0].(error) return ret0 } // WaitUntilResourceRecordSetsChangedWithContext indicates an expected call of WaitUntilResourceRecordSetsChangedWithContext func (mr *MockRoute53APIMockRecorder) WaitUntilResourceRecordSetsChangedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { mr.mock.ctrl.T.Helper() varargs := append([]interface{}{arg0, arg1}, arg2...) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilResourceRecordSetsChangedWithContext", reflect.TypeOf((*MockRoute53API)(nil).WaitUntilResourceRecordSetsChangedWithContext), varargs...) }