From 83dc68e80321d4a83e143c77e92f9a7978324b2c Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Tue, 9 Jul 2024 16:23:15 -0600 Subject: [PATCH 1/3] feat(autoscaling-launch-configuration): standardize, add properties, make ready for tests --- resources/autoscaling-launch-configuration.go | 91 +++++++++++++++++++ .../autoscaling-launch-configurations.go | 73 --------------- 2 files changed, 91 insertions(+), 73 deletions(-) create mode 100644 resources/autoscaling-launch-configuration.go delete mode 100644 resources/autoscaling-launch-configurations.go diff --git a/resources/autoscaling-launch-configuration.go b/resources/autoscaling-launch-configuration.go new file mode 100644 index 00000000..494e70bb --- /dev/null +++ b/resources/autoscaling-launch-configuration.go @@ -0,0 +1,91 @@ +package resources + +import ( + "context" + "time" + + "github.com/aws/aws-sdk-go/service/autoscaling" + "github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const AutoScalingLaunchConfigurationResource = "AutoScalingLaunchConfiguration" + +func init() { + registry.Register(®istry.Registration{ + Name: AutoScalingLaunchConfigurationResource, + Scope: nuke.Account, + Lister: &AutoScalingLaunchConfigurationLister{}, + DeprecatedAliases: []string{ + "LaunchConfiguration", + }, + }) +} + +type AutoScalingLaunchConfigurationLister struct { + mockSvc autoscalingiface.AutoScalingAPI +} + +func (l *AutoScalingLaunchConfigurationLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + resources := make([]resource.Resource, 0) + + var svc autoscalingiface.AutoScalingAPI + if l.mockSvc != nil { + svc = l.mockSvc + } else { + svc = autoscaling.New(opts.Session) + } + + params := &autoscaling.DescribeLaunchConfigurationsInput{} + err := svc.DescribeLaunchConfigurationsPages(params, + func(page *autoscaling.DescribeLaunchConfigurationsOutput, lastPage bool) bool { + for _, launchConfig := range page.LaunchConfigurations { + resources = append(resources, &AutoScalingLaunchConfiguration{ + svc: svc, + Name: launchConfig.LaunchConfigurationName, + CreatedTime: launchConfig.CreatedTime, + }) + } + return !lastPage + }) + + if err != nil { + return nil, err + } + + return resources, nil +} + +type AutoScalingLaunchConfiguration struct { + svc autoscalingiface.AutoScalingAPI + Name *string + CreatedTime *time.Time +} + +func (r *AutoScalingLaunchConfiguration) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + +func (r *AutoScalingLaunchConfiguration) Remove(_ context.Context) error { + params := &autoscaling.DeleteLaunchConfigurationInput{ + LaunchConfigurationName: r.Name, + } + + _, err := r.svc.DeleteLaunchConfiguration(params) + if err != nil { + return err + } + + return nil +} + +func (r *AutoScalingLaunchConfiguration) String() string { + return *r.Name +} diff --git a/resources/autoscaling-launch-configurations.go b/resources/autoscaling-launch-configurations.go deleted file mode 100644 index ba3891d5..00000000 --- a/resources/autoscaling-launch-configurations.go +++ /dev/null @@ -1,73 +0,0 @@ -package resources - -import ( - "context" - - "github.com/aws/aws-sdk-go/service/autoscaling" - - "github.com/ekristen/libnuke/pkg/registry" - "github.com/ekristen/libnuke/pkg/resource" - - "github.com/ekristen/aws-nuke/v3/pkg/nuke" -) - -// TODO: review if this should be prefixed with Autoscaling - -const LaunchConfigurationResource = "LaunchConfiguration" - -func init() { - registry.Register(®istry.Registration{ - Name: LaunchConfigurationResource, - Scope: nuke.Account, - Lister: &LaunchConfigurationLister{}, - }) -} - -type LaunchConfigurationLister struct{} - -func (l *LaunchConfigurationLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { - opts := o.(*nuke.ListerOpts) - - resources := make([]resource.Resource, 0) - svc := autoscaling.New(opts.Session) - - params := &autoscaling.DescribeLaunchConfigurationsInput{} - err := svc.DescribeLaunchConfigurationsPages(params, - func(page *autoscaling.DescribeLaunchConfigurationsOutput, lastPage bool) bool { - for _, launchConfig := range page.LaunchConfigurations { - resources = append(resources, &LaunchConfiguration{ - svc: svc, - name: launchConfig.LaunchConfigurationName, - }) - } - return !lastPage - }) - - if err != nil { - return nil, err - } - - return resources, nil -} - -type LaunchConfiguration struct { - svc *autoscaling.AutoScaling - name *string -} - -func (c *LaunchConfiguration) Remove(_ context.Context) error { - params := &autoscaling.DeleteLaunchConfigurationInput{ - LaunchConfigurationName: c.name, - } - - _, err := c.svc.DeleteLaunchConfiguration(params) - if err != nil { - return err - } - - return nil -} - -func (c *LaunchConfiguration) String() string { - return *c.name -} From 6e6f92dcb7b3686c019910c8dfafb4a85462e904 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Tue, 9 Jul 2024 16:23:37 -0600 Subject: [PATCH 2/3] feat(autoscaling-lifecycle-hook): standardize, add properties, make ready for tests --- resources/autoscaling-lifecycle-hook.go | 95 ++++++++++++++++++++++++ resources/autoscaling-lifecycle-hooks.go | 81 -------------------- 2 files changed, 95 insertions(+), 81 deletions(-) create mode 100644 resources/autoscaling-lifecycle-hook.go delete mode 100644 resources/autoscaling-lifecycle-hooks.go diff --git a/resources/autoscaling-lifecycle-hook.go b/resources/autoscaling-lifecycle-hook.go new file mode 100644 index 00000000..6d03348e --- /dev/null +++ b/resources/autoscaling-lifecycle-hook.go @@ -0,0 +1,95 @@ +package resources + +import ( + "context" + + "github.com/aws/aws-sdk-go/service/autoscaling" + "github.com/aws/aws-sdk-go/service/autoscaling/autoscalingiface" + + "github.com/ekristen/libnuke/pkg/registry" + "github.com/ekristen/libnuke/pkg/resource" + "github.com/ekristen/libnuke/pkg/types" + + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +const AutoScalingLifecycleHookResource = "AutoScalingLifecycleHook" + +func init() { + registry.Register(®istry.Registration{ + Name: AutoScalingLifecycleHookResource, + Scope: nuke.Account, + Lister: &AutoScalingLifecycleHookLister{}, + DeprecatedAliases: []string{ + "LifecycleHook", + }, + }) +} + +type AutoScalingLifecycleHookLister struct { + mockSvc autoscalingiface.AutoScalingAPI +} + +func (l *AutoScalingLifecycleHookLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { + opts := o.(*nuke.ListerOpts) + + var svc autoscalingiface.AutoScalingAPI + if l.mockSvc != nil { + svc = l.mockSvc + } else { + svc = autoscaling.New(opts.Session) + } + + asgResp, err := svc.DescribeAutoScalingGroups(&autoscaling.DescribeAutoScalingGroupsInput{}) + if err != nil { + return nil, err + } + + resources := make([]resource.Resource, 0) + for _, asg := range asgResp.AutoScalingGroups { + lchResp, err := svc.DescribeLifecycleHooks(&autoscaling.DescribeLifecycleHooksInput{ + AutoScalingGroupName: asg.AutoScalingGroupName, + }) + if err != nil { + return nil, err + } + + for _, lch := range lchResp.LifecycleHooks { + resources = append(resources, &AutoScalingLifecycleHook{ + svc: svc, + Name: lch.LifecycleHookName, + GroupName: lch.AutoScalingGroupName, + }) + } + } + + return resources, nil +} + +type AutoScalingLifecycleHook struct { + svc autoscalingiface.AutoScalingAPI + Name *string + GroupName *string +} + +func (r *AutoScalingLifecycleHook) Properties() types.Properties { + return types.NewPropertiesFromStruct(r) +} + +func (r *AutoScalingLifecycleHook) Remove(_ context.Context) error { + params := &autoscaling.DeleteLifecycleHookInput{ + AutoScalingGroupName: r.GroupName, + LifecycleHookName: r.Name, + } + + _, err := r.svc.DeleteLifecycleHook(params) + if err != nil { + return err + } + + return nil +} + +func (r *AutoScalingLifecycleHook) String() string { + return *r.Name +} diff --git a/resources/autoscaling-lifecycle-hooks.go b/resources/autoscaling-lifecycle-hooks.go deleted file mode 100644 index e0a69800..00000000 --- a/resources/autoscaling-lifecycle-hooks.go +++ /dev/null @@ -1,81 +0,0 @@ -package resources - -import ( - "context" - - "github.com/aws/aws-sdk-go/service/autoscaling" - - "github.com/ekristen/libnuke/pkg/registry" - "github.com/ekristen/libnuke/pkg/resource" - - "github.com/ekristen/aws-nuke/v3/pkg/nuke" -) - -// TODO: review if this should be prefixed with Autoscaling - -const LifecycleHookResource = "LifecycleHook" - -func init() { - registry.Register(®istry.Registration{ - Name: LifecycleHookResource, - Scope: nuke.Account, - Lister: &LifecycleHookLister{}, - }) -} - -type LifecycleHookLister struct{} - -func (l *LifecycleHookLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) { - opts := o.(*nuke.ListerOpts) - - svc := autoscaling.New(opts.Session) - - asgResp, err := svc.DescribeAutoScalingGroups(&autoscaling.DescribeAutoScalingGroupsInput{}) - if err != nil { - return nil, err - } - - resources := make([]resource.Resource, 0) - for _, asg := range asgResp.AutoScalingGroups { - lchResp, err := svc.DescribeLifecycleHooks(&autoscaling.DescribeLifecycleHooksInput{ - AutoScalingGroupName: asg.AutoScalingGroupName, - }) - if err != nil { - return nil, err - } - - for _, lch := range lchResp.LifecycleHooks { - resources = append(resources, &LifecycleHook{ - svc: svc, - lifecycleHookName: lch.LifecycleHookName, - autoScalingGroupName: lch.AutoScalingGroupName, - }) - } - } - - return resources, nil -} - -type LifecycleHook struct { - svc *autoscaling.AutoScaling - lifecycleHookName *string - autoScalingGroupName *string -} - -func (lch *LifecycleHook) Remove(_ context.Context) error { - params := &autoscaling.DeleteLifecycleHookInput{ - AutoScalingGroupName: lch.autoScalingGroupName, - LifecycleHookName: lch.lifecycleHookName, - } - - _, err := lch.svc.DeleteLifecycleHook(params) - if err != nil { - return err - } - - return nil -} - -func (lch *LifecycleHook) String() string { - return *lch.lifecycleHookName -} From 2971b6b5e228b92d33ed1d53caf2ee6775ce7134 Mon Sep 17 00:00:00 2001 From: Erik Kristensen Date: Tue, 9 Jul 2024 16:24:33 -0600 Subject: [PATCH 3/3] test(autoscaling): add mock tests for lifecycle hook and launch configuration --- mocks/mock_autoscalingiface/mock.go | 3815 +++++++++++++++++ ...scaling-launch-configurations_mock_test.go | 91 + .../autoscaling-lifecycle-hooks_mock_test.go | 95 + resources/autoscaling_mock_test.go | 4 + 4 files changed, 4005 insertions(+) create mode 100644 mocks/mock_autoscalingiface/mock.go create mode 100644 resources/autoscaling-launch-configurations_mock_test.go create mode 100644 resources/autoscaling-lifecycle-hooks_mock_test.go create mode 100644 resources/autoscaling_mock_test.go diff --git a/mocks/mock_autoscalingiface/mock.go b/mocks/mock_autoscalingiface/mock.go new file mode 100644 index 00000000..c422a5b9 --- /dev/null +++ b/mocks/mock_autoscalingiface/mock.go @@ -0,0 +1,3815 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.53.19/service/autoscaling/autoscalingiface/interface.go + +// Package mock_autoscalingiface is a generated GoMock package. +package mock_autoscalingiface + +import ( + reflect "reflect" + + aws "github.com/aws/aws-sdk-go/aws" + request "github.com/aws/aws-sdk-go/aws/request" + autoscaling "github.com/aws/aws-sdk-go/service/autoscaling" + gomock "github.com/golang/mock/gomock" +) + +// MockAutoScalingAPI is a mock of AutoScalingAPI interface. +type MockAutoScalingAPI struct { + ctrl *gomock.Controller + recorder *MockAutoScalingAPIMockRecorder +} + +// MockAutoScalingAPIMockRecorder is the mock recorder for MockAutoScalingAPI. +type MockAutoScalingAPIMockRecorder struct { + mock *MockAutoScalingAPI +} + +// NewMockAutoScalingAPI creates a new mock instance. +func NewMockAutoScalingAPI(ctrl *gomock.Controller) *MockAutoScalingAPI { + mock := &MockAutoScalingAPI{ctrl: ctrl} + mock.recorder = &MockAutoScalingAPIMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAutoScalingAPI) EXPECT() *MockAutoScalingAPIMockRecorder { + return m.recorder +} + +// AttachInstances mocks base method. +func (m *MockAutoScalingAPI) AttachInstances(arg0 *autoscaling.AttachInstancesInput) (*autoscaling.AttachInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachInstances", arg0) + ret0, _ := ret[0].(*autoscaling.AttachInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachInstances indicates an expected call of AttachInstances. +func (mr *MockAutoScalingAPIMockRecorder) AttachInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstances), arg0) +} + +// AttachInstancesRequest mocks base method. +func (m *MockAutoScalingAPI) AttachInstancesRequest(arg0 *autoscaling.AttachInstancesInput) (*request.Request, *autoscaling.AttachInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.AttachInstancesOutput) + return ret0, ret1 +} + +// AttachInstancesRequest indicates an expected call of AttachInstancesRequest. +func (mr *MockAutoScalingAPIMockRecorder) AttachInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstancesRequest), arg0) +} + +// AttachInstancesWithContext mocks base method. +func (m *MockAutoScalingAPI) AttachInstancesWithContext(arg0 aws.Context, arg1 *autoscaling.AttachInstancesInput, arg2 ...request.Option) (*autoscaling.AttachInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachInstancesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.AttachInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachInstancesWithContext indicates an expected call of AttachInstancesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) AttachInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachInstancesWithContext), varargs...) +} + +// AttachLoadBalancerTargetGroups mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroups(arg0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroups", arg0) + ret0, _ := ret[0].(*autoscaling.AttachLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachLoadBalancerTargetGroups indicates an expected call of AttachLoadBalancerTargetGroups. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroups), arg0) +} + +// AttachLoadBalancerTargetGroupsRequest mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroupsRequest(arg0 *autoscaling.AttachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.AttachLoadBalancerTargetGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.AttachLoadBalancerTargetGroupsOutput) + return ret0, ret1 +} + +// AttachLoadBalancerTargetGroupsRequest indicates an expected call of AttachLoadBalancerTargetGroupsRequest. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroupsRequest), arg0) +} + +// AttachLoadBalancerTargetGroupsWithContext mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancerTargetGroupsWithContext(arg0 aws.Context, arg1 *autoscaling.AttachLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.AttachLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachLoadBalancerTargetGroupsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.AttachLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachLoadBalancerTargetGroupsWithContext indicates an expected call of AttachLoadBalancerTargetGroupsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancerTargetGroupsWithContext), varargs...) +} + +// AttachLoadBalancers mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancers(arg0 *autoscaling.AttachLoadBalancersInput) (*autoscaling.AttachLoadBalancersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachLoadBalancers", arg0) + ret0, _ := ret[0].(*autoscaling.AttachLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachLoadBalancers indicates an expected call of AttachLoadBalancers. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancers), arg0) +} + +// AttachLoadBalancersRequest mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancersRequest(arg0 *autoscaling.AttachLoadBalancersInput) (*request.Request, *autoscaling.AttachLoadBalancersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachLoadBalancersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.AttachLoadBalancersOutput) + return ret0, ret1 +} + +// AttachLoadBalancersRequest indicates an expected call of AttachLoadBalancersRequest. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancersRequest), arg0) +} + +// AttachLoadBalancersWithContext mocks base method. +func (m *MockAutoScalingAPI) AttachLoadBalancersWithContext(arg0 aws.Context, arg1 *autoscaling.AttachLoadBalancersInput, arg2 ...request.Option) (*autoscaling.AttachLoadBalancersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachLoadBalancersWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.AttachLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachLoadBalancersWithContext indicates an expected call of AttachLoadBalancersWithContext. +func (mr *MockAutoScalingAPIMockRecorder) AttachLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachLoadBalancersWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachLoadBalancersWithContext), varargs...) +} + +// AttachTrafficSources mocks base method. +func (m *MockAutoScalingAPI) AttachTrafficSources(arg0 *autoscaling.AttachTrafficSourcesInput) (*autoscaling.AttachTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachTrafficSources", arg0) + ret0, _ := ret[0].(*autoscaling.AttachTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachTrafficSources indicates an expected call of AttachTrafficSources. +func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSources), arg0) +} + +// AttachTrafficSourcesRequest mocks base method. +func (m *MockAutoScalingAPI) AttachTrafficSourcesRequest(arg0 *autoscaling.AttachTrafficSourcesInput) (*request.Request, *autoscaling.AttachTrafficSourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AttachTrafficSourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.AttachTrafficSourcesOutput) + return ret0, ret1 +} + +// AttachTrafficSourcesRequest indicates an expected call of AttachTrafficSourcesRequest. +func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSourcesRequest), arg0) +} + +// AttachTrafficSourcesWithContext mocks base method. +func (m *MockAutoScalingAPI) AttachTrafficSourcesWithContext(arg0 aws.Context, arg1 *autoscaling.AttachTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.AttachTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "AttachTrafficSourcesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.AttachTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AttachTrafficSourcesWithContext indicates an expected call of AttachTrafficSourcesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) AttachTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).AttachTrafficSourcesWithContext), varargs...) +} + +// BatchDeleteScheduledAction mocks base method. +func (m *MockAutoScalingAPI) BatchDeleteScheduledAction(arg0 *autoscaling.BatchDeleteScheduledActionInput) (*autoscaling.BatchDeleteScheduledActionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteScheduledAction", arg0) + ret0, _ := ret[0].(*autoscaling.BatchDeleteScheduledActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteScheduledAction indicates an expected call of BatchDeleteScheduledAction. +func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledAction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledAction), arg0) +} + +// BatchDeleteScheduledActionRequest mocks base method. +func (m *MockAutoScalingAPI) BatchDeleteScheduledActionRequest(arg0 *autoscaling.BatchDeleteScheduledActionInput) (*request.Request, *autoscaling.BatchDeleteScheduledActionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchDeleteScheduledActionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.BatchDeleteScheduledActionOutput) + return ret0, ret1 +} + +// BatchDeleteScheduledActionRequest indicates an expected call of BatchDeleteScheduledActionRequest. +func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledActionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledActionRequest), arg0) +} + +// BatchDeleteScheduledActionWithContext mocks base method. +func (m *MockAutoScalingAPI) BatchDeleteScheduledActionWithContext(arg0 aws.Context, arg1 *autoscaling.BatchDeleteScheduledActionInput, arg2 ...request.Option) (*autoscaling.BatchDeleteScheduledActionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchDeleteScheduledActionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.BatchDeleteScheduledActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchDeleteScheduledActionWithContext indicates an expected call of BatchDeleteScheduledActionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) BatchDeleteScheduledActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchDeleteScheduledActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchDeleteScheduledActionWithContext), varargs...) +} + +// BatchPutScheduledUpdateGroupAction mocks base method. +func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupAction(arg0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*autoscaling.BatchPutScheduledUpdateGroupActionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupAction", arg0) + ret0, _ := ret[0].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchPutScheduledUpdateGroupAction indicates an expected call of BatchPutScheduledUpdateGroupAction. +func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupAction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupAction), arg0) +} + +// BatchPutScheduledUpdateGroupActionRequest mocks base method. +func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupActionRequest(arg0 *autoscaling.BatchPutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.BatchPutScheduledUpdateGroupActionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupActionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput) + return ret0, ret1 +} + +// BatchPutScheduledUpdateGroupActionRequest indicates an expected call of BatchPutScheduledUpdateGroupActionRequest. +func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupActionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupActionRequest), arg0) +} + +// BatchPutScheduledUpdateGroupActionWithContext mocks base method. +func (m *MockAutoScalingAPI) BatchPutScheduledUpdateGroupActionWithContext(arg0 aws.Context, arg1 *autoscaling.BatchPutScheduledUpdateGroupActionInput, arg2 ...request.Option) (*autoscaling.BatchPutScheduledUpdateGroupActionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BatchPutScheduledUpdateGroupActionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.BatchPutScheduledUpdateGroupActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BatchPutScheduledUpdateGroupActionWithContext indicates an expected call of BatchPutScheduledUpdateGroupActionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) BatchPutScheduledUpdateGroupActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchPutScheduledUpdateGroupActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).BatchPutScheduledUpdateGroupActionWithContext), varargs...) +} + +// CancelInstanceRefresh mocks base method. +func (m *MockAutoScalingAPI) CancelInstanceRefresh(arg0 *autoscaling.CancelInstanceRefreshInput) (*autoscaling.CancelInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelInstanceRefresh", arg0) + ret0, _ := ret[0].(*autoscaling.CancelInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelInstanceRefresh indicates an expected call of CancelInstanceRefresh. +func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefresh(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefresh), arg0) +} + +// CancelInstanceRefreshRequest mocks base method. +func (m *MockAutoScalingAPI) CancelInstanceRefreshRequest(arg0 *autoscaling.CancelInstanceRefreshInput) (*request.Request, *autoscaling.CancelInstanceRefreshOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelInstanceRefreshRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.CancelInstanceRefreshOutput) + return ret0, ret1 +} + +// CancelInstanceRefreshRequest indicates an expected call of CancelInstanceRefreshRequest. +func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefreshRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefreshRequest), arg0) +} + +// CancelInstanceRefreshWithContext mocks base method. +func (m *MockAutoScalingAPI) CancelInstanceRefreshWithContext(arg0 aws.Context, arg1 *autoscaling.CancelInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.CancelInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CancelInstanceRefreshWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.CancelInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelInstanceRefreshWithContext indicates an expected call of CancelInstanceRefreshWithContext. +func (mr *MockAutoScalingAPIMockRecorder) CancelInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CancelInstanceRefreshWithContext), varargs...) +} + +// CompleteLifecycleAction mocks base method. +func (m *MockAutoScalingAPI) CompleteLifecycleAction(arg0 *autoscaling.CompleteLifecycleActionInput) (*autoscaling.CompleteLifecycleActionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteLifecycleAction", arg0) + ret0, _ := ret[0].(*autoscaling.CompleteLifecycleActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteLifecycleAction indicates an expected call of CompleteLifecycleAction. +func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleAction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleAction), arg0) +} + +// CompleteLifecycleActionRequest mocks base method. +func (m *MockAutoScalingAPI) CompleteLifecycleActionRequest(arg0 *autoscaling.CompleteLifecycleActionInput) (*request.Request, *autoscaling.CompleteLifecycleActionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CompleteLifecycleActionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.CompleteLifecycleActionOutput) + return ret0, ret1 +} + +// CompleteLifecycleActionRequest indicates an expected call of CompleteLifecycleActionRequest. +func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleActionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleActionRequest), arg0) +} + +// CompleteLifecycleActionWithContext mocks base method. +func (m *MockAutoScalingAPI) CompleteLifecycleActionWithContext(arg0 aws.Context, arg1 *autoscaling.CompleteLifecycleActionInput, arg2 ...request.Option) (*autoscaling.CompleteLifecycleActionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CompleteLifecycleActionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.CompleteLifecycleActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CompleteLifecycleActionWithContext indicates an expected call of CompleteLifecycleActionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) CompleteLifecycleActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteLifecycleActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CompleteLifecycleActionWithContext), varargs...) +} + +// CreateAutoScalingGroup mocks base method. +func (m *MockAutoScalingAPI) CreateAutoScalingGroup(arg0 *autoscaling.CreateAutoScalingGroupInput) (*autoscaling.CreateAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAutoScalingGroup", arg0) + ret0, _ := ret[0].(*autoscaling.CreateAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAutoScalingGroup indicates an expected call of CreateAutoScalingGroup. +func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroup), arg0) +} + +// CreateAutoScalingGroupRequest mocks base method. +func (m *MockAutoScalingAPI) CreateAutoScalingGroupRequest(arg0 *autoscaling.CreateAutoScalingGroupInput) (*request.Request, *autoscaling.CreateAutoScalingGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateAutoScalingGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.CreateAutoScalingGroupOutput) + return ret0, ret1 +} + +// CreateAutoScalingGroupRequest indicates an expected call of CreateAutoScalingGroupRequest. +func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroupRequest), arg0) +} + +// CreateAutoScalingGroupWithContext mocks base method. +func (m *MockAutoScalingAPI) CreateAutoScalingGroupWithContext(arg0 aws.Context, arg1 *autoscaling.CreateAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.CreateAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateAutoScalingGroupWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.CreateAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateAutoScalingGroupWithContext indicates an expected call of CreateAutoScalingGroupWithContext. +func (mr *MockAutoScalingAPIMockRecorder) CreateAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateAutoScalingGroupWithContext), varargs...) +} + +// CreateLaunchConfiguration mocks base method. +func (m *MockAutoScalingAPI) CreateLaunchConfiguration(arg0 *autoscaling.CreateLaunchConfigurationInput) (*autoscaling.CreateLaunchConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchConfiguration", arg0) + ret0, _ := ret[0].(*autoscaling.CreateLaunchConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchConfiguration indicates an expected call of CreateLaunchConfiguration. +func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfiguration), arg0) +} + +// CreateLaunchConfigurationRequest mocks base method. +func (m *MockAutoScalingAPI) CreateLaunchConfigurationRequest(arg0 *autoscaling.CreateLaunchConfigurationInput) (*request.Request, *autoscaling.CreateLaunchConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateLaunchConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.CreateLaunchConfigurationOutput) + return ret0, ret1 +} + +// CreateLaunchConfigurationRequest indicates an expected call of CreateLaunchConfigurationRequest. +func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfigurationRequest), arg0) +} + +// CreateLaunchConfigurationWithContext mocks base method. +func (m *MockAutoScalingAPI) CreateLaunchConfigurationWithContext(arg0 aws.Context, arg1 *autoscaling.CreateLaunchConfigurationInput, arg2 ...request.Option) (*autoscaling.CreateLaunchConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateLaunchConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.CreateLaunchConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateLaunchConfigurationWithContext indicates an expected call of CreateLaunchConfigurationWithContext. +func (mr *MockAutoScalingAPIMockRecorder) CreateLaunchConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateLaunchConfigurationWithContext), varargs...) +} + +// CreateOrUpdateTags mocks base method. +func (m *MockAutoScalingAPI) CreateOrUpdateTags(arg0 *autoscaling.CreateOrUpdateTagsInput) (*autoscaling.CreateOrUpdateTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOrUpdateTags", arg0) + ret0, _ := ret[0].(*autoscaling.CreateOrUpdateTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOrUpdateTags indicates an expected call of CreateOrUpdateTags. +func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTags), arg0) +} + +// CreateOrUpdateTagsRequest mocks base method. +func (m *MockAutoScalingAPI) CreateOrUpdateTagsRequest(arg0 *autoscaling.CreateOrUpdateTagsInput) (*request.Request, *autoscaling.CreateOrUpdateTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateOrUpdateTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.CreateOrUpdateTagsOutput) + return ret0, ret1 +} + +// CreateOrUpdateTagsRequest indicates an expected call of CreateOrUpdateTagsRequest. +func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTagsRequest), arg0) +} + +// CreateOrUpdateTagsWithContext mocks base method. +func (m *MockAutoScalingAPI) CreateOrUpdateTagsWithContext(arg0 aws.Context, arg1 *autoscaling.CreateOrUpdateTagsInput, arg2 ...request.Option) (*autoscaling.CreateOrUpdateTagsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "CreateOrUpdateTagsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.CreateOrUpdateTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateOrUpdateTagsWithContext indicates an expected call of CreateOrUpdateTagsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) CreateOrUpdateTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateTagsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).CreateOrUpdateTagsWithContext), varargs...) +} + +// DeleteAutoScalingGroup mocks base method. +func (m *MockAutoScalingAPI) DeleteAutoScalingGroup(arg0 *autoscaling.DeleteAutoScalingGroupInput) (*autoscaling.DeleteAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAutoScalingGroup", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAutoScalingGroup indicates an expected call of DeleteAutoScalingGroup. +func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroup), arg0) +} + +// DeleteAutoScalingGroupRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteAutoScalingGroupRequest(arg0 *autoscaling.DeleteAutoScalingGroupInput) (*request.Request, *autoscaling.DeleteAutoScalingGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteAutoScalingGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteAutoScalingGroupOutput) + return ret0, ret1 +} + +// DeleteAutoScalingGroupRequest indicates an expected call of DeleteAutoScalingGroupRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroupRequest), arg0) +} + +// DeleteAutoScalingGroupWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteAutoScalingGroupWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.DeleteAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteAutoScalingGroupWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteAutoScalingGroupWithContext indicates an expected call of DeleteAutoScalingGroupWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteAutoScalingGroupWithContext), varargs...) +} + +// DeleteLaunchConfiguration mocks base method. +func (m *MockAutoScalingAPI) DeleteLaunchConfiguration(arg0 *autoscaling.DeleteLaunchConfigurationInput) (*autoscaling.DeleteLaunchConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchConfiguration", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteLaunchConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchConfiguration indicates an expected call of DeleteLaunchConfiguration. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfiguration), arg0) +} + +// DeleteLaunchConfigurationRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteLaunchConfigurationRequest(arg0 *autoscaling.DeleteLaunchConfigurationInput) (*request.Request, *autoscaling.DeleteLaunchConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLaunchConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteLaunchConfigurationOutput) + return ret0, ret1 +} + +// DeleteLaunchConfigurationRequest indicates an expected call of DeleteLaunchConfigurationRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfigurationRequest), arg0) +} + +// DeleteLaunchConfigurationWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteLaunchConfigurationWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteLaunchConfigurationInput, arg2 ...request.Option) (*autoscaling.DeleteLaunchConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLaunchConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteLaunchConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLaunchConfigurationWithContext indicates an expected call of DeleteLaunchConfigurationWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLaunchConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLaunchConfigurationWithContext), varargs...) +} + +// DeleteLifecycleHook mocks base method. +func (m *MockAutoScalingAPI) DeleteLifecycleHook(arg0 *autoscaling.DeleteLifecycleHookInput) (*autoscaling.DeleteLifecycleHookOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLifecycleHook", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteLifecycleHookOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLifecycleHook indicates an expected call of DeleteLifecycleHook. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHook(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHook), arg0) +} + +// DeleteLifecycleHookRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteLifecycleHookRequest(arg0 *autoscaling.DeleteLifecycleHookInput) (*request.Request, *autoscaling.DeleteLifecycleHookOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteLifecycleHookRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteLifecycleHookOutput) + return ret0, ret1 +} + +// DeleteLifecycleHookRequest indicates an expected call of DeleteLifecycleHookRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHookRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHookRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHookRequest), arg0) +} + +// DeleteLifecycleHookWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteLifecycleHookWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteLifecycleHookInput, arg2 ...request.Option) (*autoscaling.DeleteLifecycleHookOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteLifecycleHookWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteLifecycleHookOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteLifecycleHookWithContext indicates an expected call of DeleteLifecycleHookWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteLifecycleHookWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLifecycleHookWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteLifecycleHookWithContext), varargs...) +} + +// DeleteNotificationConfiguration mocks base method. +func (m *MockAutoScalingAPI) DeleteNotificationConfiguration(arg0 *autoscaling.DeleteNotificationConfigurationInput) (*autoscaling.DeleteNotificationConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNotificationConfiguration", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNotificationConfiguration indicates an expected call of DeleteNotificationConfiguration. +func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfiguration), arg0) +} + +// DeleteNotificationConfigurationRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteNotificationConfigurationRequest(arg0 *autoscaling.DeleteNotificationConfigurationInput) (*request.Request, *autoscaling.DeleteNotificationConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteNotificationConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteNotificationConfigurationOutput) + return ret0, ret1 +} + +// DeleteNotificationConfigurationRequest indicates an expected call of DeleteNotificationConfigurationRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfigurationRequest), arg0) +} + +// DeleteNotificationConfigurationWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteNotificationConfigurationWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteNotificationConfigurationInput, arg2 ...request.Option) (*autoscaling.DeleteNotificationConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteNotificationConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteNotificationConfigurationWithContext indicates an expected call of DeleteNotificationConfigurationWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNotificationConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteNotificationConfigurationWithContext), varargs...) +} + +// DeletePolicy mocks base method. +func (m *MockAutoScalingAPI) DeletePolicy(arg0 *autoscaling.DeletePolicyInput) (*autoscaling.DeletePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicy", arg0) + ret0, _ := ret[0].(*autoscaling.DeletePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicy indicates an expected call of DeletePolicy. +func (mr *MockAutoScalingAPIMockRecorder) DeletePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicy), arg0) +} + +// DeletePolicyRequest mocks base method. +func (m *MockAutoScalingAPI) DeletePolicyRequest(arg0 *autoscaling.DeletePolicyInput) (*request.Request, *autoscaling.DeletePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeletePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeletePolicyOutput) + return ret0, ret1 +} + +// DeletePolicyRequest indicates an expected call of DeletePolicyRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeletePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicyRequest), arg0) +} + +// DeletePolicyWithContext mocks base method. +func (m *MockAutoScalingAPI) DeletePolicyWithContext(arg0 aws.Context, arg1 *autoscaling.DeletePolicyInput, arg2 ...request.Option) (*autoscaling.DeletePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeletePolicyWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeletePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeletePolicyWithContext indicates an expected call of DeletePolicyWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeletePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeletePolicyWithContext), varargs...) +} + +// DeleteScheduledAction mocks base method. +func (m *MockAutoScalingAPI) DeleteScheduledAction(arg0 *autoscaling.DeleteScheduledActionInput) (*autoscaling.DeleteScheduledActionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScheduledAction", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteScheduledActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScheduledAction indicates an expected call of DeleteScheduledAction. +func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledAction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledAction), arg0) +} + +// DeleteScheduledActionRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteScheduledActionRequest(arg0 *autoscaling.DeleteScheduledActionInput) (*request.Request, *autoscaling.DeleteScheduledActionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteScheduledActionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteScheduledActionOutput) + return ret0, ret1 +} + +// DeleteScheduledActionRequest indicates an expected call of DeleteScheduledActionRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledActionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledActionRequest), arg0) +} + +// DeleteScheduledActionWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteScheduledActionWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteScheduledActionInput, arg2 ...request.Option) (*autoscaling.DeleteScheduledActionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteScheduledActionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteScheduledActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteScheduledActionWithContext indicates an expected call of DeleteScheduledActionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteScheduledActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteScheduledActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteScheduledActionWithContext), varargs...) +} + +// DeleteTags mocks base method. +func (m *MockAutoScalingAPI) DeleteTags(arg0 *autoscaling.DeleteTagsInput) (*autoscaling.DeleteTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTags", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTags indicates an expected call of DeleteTags. +func (mr *MockAutoScalingAPIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTags), arg0) +} + +// DeleteTagsRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteTagsRequest(arg0 *autoscaling.DeleteTagsInput) (*request.Request, *autoscaling.DeleteTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteTagsOutput) + return ret0, ret1 +} + +// DeleteTagsRequest indicates an expected call of DeleteTagsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteTagsRequest), arg0) +} + +// DeleteTagsWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteTagsWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteTagsInput, arg2 ...request.Option) (*autoscaling.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].(*autoscaling.DeleteTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DeleteTagsWithContext), varargs...) +} + +// DeleteWarmPool mocks base method. +func (m *MockAutoScalingAPI) DeleteWarmPool(arg0 *autoscaling.DeleteWarmPoolInput) (*autoscaling.DeleteWarmPoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteWarmPool", arg0) + ret0, _ := ret[0].(*autoscaling.DeleteWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteWarmPool indicates an expected call of DeleteWarmPool. +func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPool), arg0) +} + +// DeleteWarmPoolRequest mocks base method. +func (m *MockAutoScalingAPI) DeleteWarmPoolRequest(arg0 *autoscaling.DeleteWarmPoolInput) (*request.Request, *autoscaling.DeleteWarmPoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DeleteWarmPoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DeleteWarmPoolOutput) + return ret0, ret1 +} + +// DeleteWarmPoolRequest indicates an expected call of DeleteWarmPoolRequest. +func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPoolRequest), arg0) +} + +// DeleteWarmPoolWithContext mocks base method. +func (m *MockAutoScalingAPI) DeleteWarmPoolWithContext(arg0 aws.Context, arg1 *autoscaling.DeleteWarmPoolInput, arg2 ...request.Option) (*autoscaling.DeleteWarmPoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DeleteWarmPoolWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DeleteWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DeleteWarmPoolWithContext indicates an expected call of DeleteWarmPoolWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DeleteWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DeleteWarmPoolWithContext), varargs...) +} + +// DescribeAccountLimits mocks base method. +func (m *MockAutoScalingAPI) DescribeAccountLimits(arg0 *autoscaling.DescribeAccountLimitsInput) (*autoscaling.DescribeAccountLimitsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountLimits", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeAccountLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountLimits indicates an expected call of DescribeAccountLimits. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAccountLimits(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimits", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAccountLimits), arg0) +} + +// DescribeAccountLimitsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeAccountLimitsRequest(arg0 *autoscaling.DescribeAccountLimitsInput) (*request.Request, *autoscaling.DescribeAccountLimitsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAccountLimitsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeAccountLimitsOutput) + return ret0, ret1 +} + +// DescribeAccountLimitsRequest indicates an expected call of DescribeAccountLimitsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAccountLimitsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountLimitsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAccountLimitsRequest), arg0) +} + +// DescribeAccountLimitsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAccountLimitsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAccountLimitsInput, arg2 ...request.Option) (*autoscaling.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].(*autoscaling.DescribeAccountLimitsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAccountLimitsWithContext indicates an expected call of DescribeAccountLimitsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DescribeAccountLimitsWithContext), varargs...) +} + +// DescribeAdjustmentTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeAdjustmentTypes(arg0 *autoscaling.DescribeAdjustmentTypesInput) (*autoscaling.DescribeAdjustmentTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAdjustmentTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeAdjustmentTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAdjustmentTypes indicates an expected call of DescribeAdjustmentTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypes), arg0) +} + +// DescribeAdjustmentTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeAdjustmentTypesRequest(arg0 *autoscaling.DescribeAdjustmentTypesInput) (*request.Request, *autoscaling.DescribeAdjustmentTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAdjustmentTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeAdjustmentTypesOutput) + return ret0, ret1 +} + +// DescribeAdjustmentTypesRequest indicates an expected call of DescribeAdjustmentTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypesRequest), arg0) +} + +// DescribeAdjustmentTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAdjustmentTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAdjustmentTypesInput, arg2 ...request.Option) (*autoscaling.DescribeAdjustmentTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAdjustmentTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeAdjustmentTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAdjustmentTypesWithContext indicates an expected call of DescribeAdjustmentTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAdjustmentTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAdjustmentTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAdjustmentTypesWithContext), varargs...) +} + +// DescribeAutoScalingGroups mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingGroups(arg0 *autoscaling.DescribeAutoScalingGroupsInput) (*autoscaling.DescribeAutoScalingGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingGroups", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingGroups indicates an expected call of DescribeAutoScalingGroups. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroups), arg0) +} + +// DescribeAutoScalingGroupsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsPages(arg0 *autoscaling.DescribeAutoScalingGroupsInput, arg1 func(*autoscaling.DescribeAutoScalingGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAutoScalingGroupsPages indicates an expected call of DescribeAutoScalingGroupsPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsPages), arg0, arg1) +} + +// DescribeAutoScalingGroupsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 func(*autoscaling.DescribeAutoScalingGroupsOutput, 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, "DescribeAutoScalingGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAutoScalingGroupsPagesWithContext indicates an expected call of DescribeAutoScalingGroupsPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsPagesWithContext(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, "DescribeAutoScalingGroupsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsPagesWithContext), varargs...) +} + +// DescribeAutoScalingGroupsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsRequest(arg0 *autoscaling.DescribeAutoScalingGroupsInput) (*request.Request, *autoscaling.DescribeAutoScalingGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingGroupsOutput) + return ret0, ret1 +} + +// DescribeAutoScalingGroupsRequest indicates an expected call of DescribeAutoScalingGroupsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsRequest), arg0) +} + +// DescribeAutoScalingGroupsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingGroupsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAutoScalingGroupsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingGroupsWithContext indicates an expected call of DescribeAutoScalingGroupsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingGroupsWithContext), varargs...) +} + +// DescribeAutoScalingInstances mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingInstances(arg0 *autoscaling.DescribeAutoScalingInstancesInput) (*autoscaling.DescribeAutoScalingInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingInstances", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingInstances indicates an expected call of DescribeAutoScalingInstances. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstances), arg0) +} + +// DescribeAutoScalingInstancesPages mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesPages(arg0 *autoscaling.DescribeAutoScalingInstancesInput, arg1 func(*autoscaling.DescribeAutoScalingInstancesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAutoScalingInstancesPages indicates an expected call of DescribeAutoScalingInstancesPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesPages), arg0, arg1) +} + +// DescribeAutoScalingInstancesPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingInstancesInput, arg2 func(*autoscaling.DescribeAutoScalingInstancesOutput, 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, "DescribeAutoScalingInstancesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeAutoScalingInstancesPagesWithContext indicates an expected call of DescribeAutoScalingInstancesPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesPagesWithContext(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, "DescribeAutoScalingInstancesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesPagesWithContext), varargs...) +} + +// DescribeAutoScalingInstancesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesRequest(arg0 *autoscaling.DescribeAutoScalingInstancesInput) (*request.Request, *autoscaling.DescribeAutoScalingInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingInstancesOutput) + return ret0, ret1 +} + +// DescribeAutoScalingInstancesRequest indicates an expected call of DescribeAutoScalingInstancesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesRequest), arg0) +} + +// DescribeAutoScalingInstancesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingInstancesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingInstancesInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAutoScalingInstancesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingInstancesWithContext indicates an expected call of DescribeAutoScalingInstancesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingInstancesWithContext), varargs...) +} + +// DescribeAutoScalingNotificationTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypes(arg0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingNotificationTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingNotificationTypes indicates an expected call of DescribeAutoScalingNotificationTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypes), arg0) +} + +// DescribeAutoScalingNotificationTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypesRequest(arg0 *autoscaling.DescribeAutoScalingNotificationTypesInput) (*request.Request, *autoscaling.DescribeAutoScalingNotificationTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeAutoScalingNotificationTypesOutput) + return ret0, ret1 +} + +// DescribeAutoScalingNotificationTypesRequest indicates an expected call of DescribeAutoScalingNotificationTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypesRequest), arg0) +} + +// DescribeAutoScalingNotificationTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeAutoScalingNotificationTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingNotificationTypesInput, arg2 ...request.Option) (*autoscaling.DescribeAutoScalingNotificationTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeAutoScalingNotificationTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeAutoScalingNotificationTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeAutoScalingNotificationTypesWithContext indicates an expected call of DescribeAutoScalingNotificationTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeAutoScalingNotificationTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAutoScalingNotificationTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeAutoScalingNotificationTypesWithContext), varargs...) +} + +// DescribeInstanceRefreshes mocks base method. +func (m *MockAutoScalingAPI) DescribeInstanceRefreshes(arg0 *autoscaling.DescribeInstanceRefreshesInput) (*autoscaling.DescribeInstanceRefreshesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceRefreshes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeInstanceRefreshesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceRefreshes indicates an expected call of DescribeInstanceRefreshes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshes), arg0) +} + +// DescribeInstanceRefreshesPages mocks base method. +func (m *MockAutoScalingAPI) DescribeInstanceRefreshesPages(arg0 *autoscaling.DescribeInstanceRefreshesInput, arg1 func(*autoscaling.DescribeInstanceRefreshesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceRefreshesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceRefreshesPages indicates an expected call of DescribeInstanceRefreshesPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesPages), arg0, arg1) +} + +// DescribeInstanceRefreshesPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeInstanceRefreshesPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeInstanceRefreshesInput, arg2 func(*autoscaling.DescribeInstanceRefreshesOutput, 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, "DescribeInstanceRefreshesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeInstanceRefreshesPagesWithContext indicates an expected call of DescribeInstanceRefreshesPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesPagesWithContext(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, "DescribeInstanceRefreshesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesPagesWithContext), varargs...) +} + +// DescribeInstanceRefreshesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeInstanceRefreshesRequest(arg0 *autoscaling.DescribeInstanceRefreshesInput) (*request.Request, *autoscaling.DescribeInstanceRefreshesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeInstanceRefreshesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeInstanceRefreshesOutput) + return ret0, ret1 +} + +// DescribeInstanceRefreshesRequest indicates an expected call of DescribeInstanceRefreshesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesRequest), arg0) +} + +// DescribeInstanceRefreshesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeInstanceRefreshesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeInstanceRefreshesInput, arg2 ...request.Option) (*autoscaling.DescribeInstanceRefreshesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeInstanceRefreshesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeInstanceRefreshesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeInstanceRefreshesWithContext indicates an expected call of DescribeInstanceRefreshesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeInstanceRefreshesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceRefreshesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeInstanceRefreshesWithContext), varargs...) +} + +// DescribeLaunchConfigurations mocks base method. +func (m *MockAutoScalingAPI) DescribeLaunchConfigurations(arg0 *autoscaling.DescribeLaunchConfigurationsInput) (*autoscaling.DescribeLaunchConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchConfigurations", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeLaunchConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchConfigurations indicates an expected call of DescribeLaunchConfigurations. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurations", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurations), arg0) +} + +// DescribeLaunchConfigurationsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsPages(arg0 *autoscaling.DescribeLaunchConfigurationsInput, arg1 func(*autoscaling.DescribeLaunchConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchConfigurationsPages indicates an expected call of DescribeLaunchConfigurationsPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsPages), arg0, arg1) +} + +// DescribeLaunchConfigurationsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLaunchConfigurationsInput, arg2 func(*autoscaling.DescribeLaunchConfigurationsOutput, 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, "DescribeLaunchConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLaunchConfigurationsPagesWithContext indicates an expected call of DescribeLaunchConfigurationsPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsPagesWithContext(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, "DescribeLaunchConfigurationsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsPagesWithContext), varargs...) +} + +// DescribeLaunchConfigurationsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsRequest(arg0 *autoscaling.DescribeLaunchConfigurationsInput) (*request.Request, *autoscaling.DescribeLaunchConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeLaunchConfigurationsOutput) + return ret0, ret1 +} + +// DescribeLaunchConfigurationsRequest indicates an expected call of DescribeLaunchConfigurationsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsRequest), arg0) +} + +// DescribeLaunchConfigurationsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLaunchConfigurationsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLaunchConfigurationsInput, arg2 ...request.Option) (*autoscaling.DescribeLaunchConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLaunchConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeLaunchConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLaunchConfigurationsWithContext indicates an expected call of DescribeLaunchConfigurationsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLaunchConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchConfigurationsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLaunchConfigurationsWithContext), varargs...) +} + +// DescribeLifecycleHookTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHookTypes(arg0 *autoscaling.DescribeLifecycleHookTypesInput) (*autoscaling.DescribeLifecycleHookTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLifecycleHookTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHookTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLifecycleHookTypes indicates an expected call of DescribeLifecycleHookTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypes), arg0) +} + +// DescribeLifecycleHookTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHookTypesRequest(arg0 *autoscaling.DescribeLifecycleHookTypesInput) (*request.Request, *autoscaling.DescribeLifecycleHookTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLifecycleHookTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeLifecycleHookTypesOutput) + return ret0, ret1 +} + +// DescribeLifecycleHookTypesRequest indicates an expected call of DescribeLifecycleHookTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypesRequest), arg0) +} + +// DescribeLifecycleHookTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHookTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLifecycleHookTypesInput, arg2 ...request.Option) (*autoscaling.DescribeLifecycleHookTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLifecycleHookTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHookTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLifecycleHookTypesWithContext indicates an expected call of DescribeLifecycleHookTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHookTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHookTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHookTypesWithContext), varargs...) +} + +// DescribeLifecycleHooks mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHooks(arg0 *autoscaling.DescribeLifecycleHooksInput) (*autoscaling.DescribeLifecycleHooksOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLifecycleHooks", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHooksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLifecycleHooks indicates an expected call of DescribeLifecycleHooks. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooks(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooks", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooks), arg0) +} + +// DescribeLifecycleHooksRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHooksRequest(arg0 *autoscaling.DescribeLifecycleHooksInput) (*request.Request, *autoscaling.DescribeLifecycleHooksOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLifecycleHooksRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeLifecycleHooksOutput) + return ret0, ret1 +} + +// DescribeLifecycleHooksRequest indicates an expected call of DescribeLifecycleHooksRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooksRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooksRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooksRequest), arg0) +} + +// DescribeLifecycleHooksWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLifecycleHooksWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLifecycleHooksInput, arg2 ...request.Option) (*autoscaling.DescribeLifecycleHooksOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLifecycleHooksWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeLifecycleHooksOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLifecycleHooksWithContext indicates an expected call of DescribeLifecycleHooksWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLifecycleHooksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLifecycleHooksWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLifecycleHooksWithContext), varargs...) +} + +// DescribeLoadBalancerTargetGroups mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroups(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroups", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLoadBalancerTargetGroups indicates an expected call of DescribeLoadBalancerTargetGroups. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroups), arg0) +} + +// DescribeLoadBalancerTargetGroupsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsPages(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg1 func(*autoscaling.DescribeLoadBalancerTargetGroupsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLoadBalancerTargetGroupsPages indicates an expected call of DescribeLoadBalancerTargetGroupsPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsPages), arg0, arg1) +} + +// DescribeLoadBalancerTargetGroupsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg2 func(*autoscaling.DescribeLoadBalancerTargetGroupsOutput, 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, "DescribeLoadBalancerTargetGroupsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeLoadBalancerTargetGroupsPagesWithContext indicates an expected call of DescribeLoadBalancerTargetGroupsPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsPagesWithContext(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, "DescribeLoadBalancerTargetGroupsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsPagesWithContext), varargs...) +} + +// DescribeLoadBalancerTargetGroupsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsRequest(arg0 *autoscaling.DescribeLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DescribeLoadBalancerTargetGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput) + return ret0, ret1 +} + +// DescribeLoadBalancerTargetGroupsRequest indicates an expected call of DescribeLoadBalancerTargetGroupsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsRequest), arg0) +} + +// DescribeLoadBalancerTargetGroupsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancerTargetGroupsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.DescribeLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeLoadBalancerTargetGroupsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLoadBalancerTargetGroupsWithContext indicates an expected call of DescribeLoadBalancerTargetGroupsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancerTargetGroupsWithContext), varargs...) +} + +// DescribeLoadBalancers mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancers(arg0 *autoscaling.DescribeLoadBalancersInput) (*autoscaling.DescribeLoadBalancersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLoadBalancers", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLoadBalancers indicates an expected call of DescribeLoadBalancers. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancers), arg0) +} + +// DescribeLoadBalancersPages mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancersPages(arg0 *autoscaling.DescribeLoadBalancersInput, arg1 func(*autoscaling.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 *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersPages), arg0, arg1) +} + +// DescribeLoadBalancersPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancersPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLoadBalancersInput, arg2 func(*autoscaling.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 *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DescribeLoadBalancersPagesWithContext), varargs...) +} + +// DescribeLoadBalancersRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancersRequest(arg0 *autoscaling.DescribeLoadBalancersInput) (*request.Request, *autoscaling.DescribeLoadBalancersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeLoadBalancersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeLoadBalancersOutput) + return ret0, ret1 +} + +// DescribeLoadBalancersRequest indicates an expected call of DescribeLoadBalancersRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeLoadBalancersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeLoadBalancersRequest), arg0) +} + +// DescribeLoadBalancersWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeLoadBalancersWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeLoadBalancersInput, arg2 ...request.Option) (*autoscaling.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].(*autoscaling.DescribeLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeLoadBalancersWithContext indicates an expected call of DescribeLoadBalancersWithContext. +func (mr *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DescribeLoadBalancersWithContext), varargs...) +} + +// DescribeMetricCollectionTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeMetricCollectionTypes(arg0 *autoscaling.DescribeMetricCollectionTypesInput) (*autoscaling.DescribeMetricCollectionTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMetricCollectionTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeMetricCollectionTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMetricCollectionTypes indicates an expected call of DescribeMetricCollectionTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypes), arg0) +} + +// DescribeMetricCollectionTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeMetricCollectionTypesRequest(arg0 *autoscaling.DescribeMetricCollectionTypesInput) (*request.Request, *autoscaling.DescribeMetricCollectionTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeMetricCollectionTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeMetricCollectionTypesOutput) + return ret0, ret1 +} + +// DescribeMetricCollectionTypesRequest indicates an expected call of DescribeMetricCollectionTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypesRequest), arg0) +} + +// DescribeMetricCollectionTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeMetricCollectionTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeMetricCollectionTypesInput, arg2 ...request.Option) (*autoscaling.DescribeMetricCollectionTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeMetricCollectionTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeMetricCollectionTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeMetricCollectionTypesWithContext indicates an expected call of DescribeMetricCollectionTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeMetricCollectionTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMetricCollectionTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeMetricCollectionTypesWithContext), varargs...) +} + +// DescribeNotificationConfigurations mocks base method. +func (m *MockAutoScalingAPI) DescribeNotificationConfigurations(arg0 *autoscaling.DescribeNotificationConfigurationsInput) (*autoscaling.DescribeNotificationConfigurationsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNotificationConfigurations", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeNotificationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNotificationConfigurations indicates an expected call of DescribeNotificationConfigurations. +func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurations(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurations", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurations), arg0) +} + +// DescribeNotificationConfigurationsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsPages(arg0 *autoscaling.DescribeNotificationConfigurationsInput, arg1 func(*autoscaling.DescribeNotificationConfigurationsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNotificationConfigurationsPages indicates an expected call of DescribeNotificationConfigurationsPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsPages), arg0, arg1) +} + +// DescribeNotificationConfigurationsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeNotificationConfigurationsInput, arg2 func(*autoscaling.DescribeNotificationConfigurationsOutput, 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, "DescribeNotificationConfigurationsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeNotificationConfigurationsPagesWithContext indicates an expected call of DescribeNotificationConfigurationsPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsPagesWithContext(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, "DescribeNotificationConfigurationsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsPagesWithContext), varargs...) +} + +// DescribeNotificationConfigurationsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsRequest(arg0 *autoscaling.DescribeNotificationConfigurationsInput) (*request.Request, *autoscaling.DescribeNotificationConfigurationsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeNotificationConfigurationsOutput) + return ret0, ret1 +} + +// DescribeNotificationConfigurationsRequest indicates an expected call of DescribeNotificationConfigurationsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsRequest), arg0) +} + +// DescribeNotificationConfigurationsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeNotificationConfigurationsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeNotificationConfigurationsInput, arg2 ...request.Option) (*autoscaling.DescribeNotificationConfigurationsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeNotificationConfigurationsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeNotificationConfigurationsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeNotificationConfigurationsWithContext indicates an expected call of DescribeNotificationConfigurationsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeNotificationConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNotificationConfigurationsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeNotificationConfigurationsWithContext), varargs...) +} + +// DescribePolicies mocks base method. +func (m *MockAutoScalingAPI) DescribePolicies(arg0 *autoscaling.DescribePoliciesInput) (*autoscaling.DescribePoliciesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePolicies", arg0) + ret0, _ := ret[0].(*autoscaling.DescribePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePolicies indicates an expected call of DescribePolicies. +func (mr *MockAutoScalingAPIMockRecorder) DescribePolicies(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePolicies", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePolicies), arg0) +} + +// DescribePoliciesPages mocks base method. +func (m *MockAutoScalingAPI) DescribePoliciesPages(arg0 *autoscaling.DescribePoliciesInput, arg1 func(*autoscaling.DescribePoliciesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePoliciesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePoliciesPages indicates an expected call of DescribePoliciesPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesPages), arg0, arg1) +} + +// DescribePoliciesPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribePoliciesPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribePoliciesInput, arg2 func(*autoscaling.DescribePoliciesOutput, 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, "DescribePoliciesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribePoliciesPagesWithContext indicates an expected call of DescribePoliciesPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesPagesWithContext(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, "DescribePoliciesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesPagesWithContext), varargs...) +} + +// DescribePoliciesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribePoliciesRequest(arg0 *autoscaling.DescribePoliciesInput) (*request.Request, *autoscaling.DescribePoliciesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribePoliciesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribePoliciesOutput) + return ret0, ret1 +} + +// DescribePoliciesRequest indicates an expected call of DescribePoliciesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesRequest), arg0) +} + +// DescribePoliciesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribePoliciesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribePoliciesInput, arg2 ...request.Option) (*autoscaling.DescribePoliciesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribePoliciesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribePoliciesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribePoliciesWithContext indicates an expected call of DescribePoliciesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribePoliciesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePoliciesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribePoliciesWithContext), varargs...) +} + +// DescribeScalingActivities mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingActivities(arg0 *autoscaling.DescribeScalingActivitiesInput) (*autoscaling.DescribeScalingActivitiesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingActivities", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeScalingActivitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingActivities indicates an expected call of DescribeScalingActivities. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivities(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivities", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivities), arg0) +} + +// DescribeScalingActivitiesPages mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingActivitiesPages(arg0 *autoscaling.DescribeScalingActivitiesInput, arg1 func(*autoscaling.DescribeScalingActivitiesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingActivitiesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScalingActivitiesPages indicates an expected call of DescribeScalingActivitiesPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesPages), arg0, arg1) +} + +// DescribeScalingActivitiesPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingActivitiesPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeScalingActivitiesInput, arg2 func(*autoscaling.DescribeScalingActivitiesOutput, 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, "DescribeScalingActivitiesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScalingActivitiesPagesWithContext indicates an expected call of DescribeScalingActivitiesPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesPagesWithContext(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, "DescribeScalingActivitiesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesPagesWithContext), varargs...) +} + +// DescribeScalingActivitiesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingActivitiesRequest(arg0 *autoscaling.DescribeScalingActivitiesInput) (*request.Request, *autoscaling.DescribeScalingActivitiesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingActivitiesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeScalingActivitiesOutput) + return ret0, ret1 +} + +// DescribeScalingActivitiesRequest indicates an expected call of DescribeScalingActivitiesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesRequest), arg0) +} + +// DescribeScalingActivitiesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingActivitiesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeScalingActivitiesInput, arg2 ...request.Option) (*autoscaling.DescribeScalingActivitiesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScalingActivitiesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeScalingActivitiesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingActivitiesWithContext indicates an expected call of DescribeScalingActivitiesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingActivitiesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingActivitiesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingActivitiesWithContext), varargs...) +} + +// DescribeScalingProcessTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingProcessTypes(arg0 *autoscaling.DescribeScalingProcessTypesInput) (*autoscaling.DescribeScalingProcessTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingProcessTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeScalingProcessTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingProcessTypes indicates an expected call of DescribeScalingProcessTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypes), arg0) +} + +// DescribeScalingProcessTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingProcessTypesRequest(arg0 *autoscaling.DescribeScalingProcessTypesInput) (*request.Request, *autoscaling.DescribeScalingProcessTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScalingProcessTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeScalingProcessTypesOutput) + return ret0, ret1 +} + +// DescribeScalingProcessTypesRequest indicates an expected call of DescribeScalingProcessTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypesRequest), arg0) +} + +// DescribeScalingProcessTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeScalingProcessTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeScalingProcessTypesInput, arg2 ...request.Option) (*autoscaling.DescribeScalingProcessTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScalingProcessTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeScalingProcessTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScalingProcessTypesWithContext indicates an expected call of DescribeScalingProcessTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScalingProcessTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScalingProcessTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScalingProcessTypesWithContext), varargs...) +} + +// DescribeScheduledActions mocks base method. +func (m *MockAutoScalingAPI) DescribeScheduledActions(arg0 *autoscaling.DescribeScheduledActionsInput) (*autoscaling.DescribeScheduledActionsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledActions", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeScheduledActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledActions indicates an expected call of DescribeScheduledActions. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActions(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActions", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActions), arg0) +} + +// DescribeScheduledActionsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeScheduledActionsPages(arg0 *autoscaling.DescribeScheduledActionsInput, arg1 func(*autoscaling.DescribeScheduledActionsOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledActionsPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledActionsPages indicates an expected call of DescribeScheduledActionsPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsPages), arg0, arg1) +} + +// DescribeScheduledActionsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeScheduledActionsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeScheduledActionsInput, arg2 func(*autoscaling.DescribeScheduledActionsOutput, 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, "DescribeScheduledActionsPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeScheduledActionsPagesWithContext indicates an expected call of DescribeScheduledActionsPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsPagesWithContext(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, "DescribeScheduledActionsPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsPagesWithContext), varargs...) +} + +// DescribeScheduledActionsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeScheduledActionsRequest(arg0 *autoscaling.DescribeScheduledActionsInput) (*request.Request, *autoscaling.DescribeScheduledActionsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeScheduledActionsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeScheduledActionsOutput) + return ret0, ret1 +} + +// DescribeScheduledActionsRequest indicates an expected call of DescribeScheduledActionsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsRequest), arg0) +} + +// DescribeScheduledActionsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeScheduledActionsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeScheduledActionsInput, arg2 ...request.Option) (*autoscaling.DescribeScheduledActionsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeScheduledActionsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeScheduledActionsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeScheduledActionsWithContext indicates an expected call of DescribeScheduledActionsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeScheduledActionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledActionsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeScheduledActionsWithContext), varargs...) +} + +// DescribeTags mocks base method. +func (m *MockAutoScalingAPI) DescribeTags(arg0 *autoscaling.DescribeTagsInput) (*autoscaling.DescribeTagsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTags", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTags indicates an expected call of DescribeTags. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTags), arg0) +} + +// DescribeTagsPages mocks base method. +func (m *MockAutoScalingAPI) DescribeTagsPages(arg0 *autoscaling.DescribeTagsInput, arg1 func(*autoscaling.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 *MockAutoScalingAPIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsPages), arg0, arg1) +} + +// DescribeTagsPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeTagsPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeTagsInput, arg2 func(*autoscaling.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 *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DescribeTagsPagesWithContext), varargs...) +} + +// DescribeTagsRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeTagsRequest(arg0 *autoscaling.DescribeTagsInput) (*request.Request, *autoscaling.DescribeTagsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeTagsOutput) + return ret0, ret1 +} + +// DescribeTagsRequest indicates an expected call of DescribeTagsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTagsRequest), arg0) +} + +// DescribeTagsWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeTagsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeTagsInput, arg2 ...request.Option) (*autoscaling.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].(*autoscaling.DescribeTagsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) 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((*MockAutoScalingAPI)(nil).DescribeTagsWithContext), varargs...) +} + +// DescribeTerminationPolicyTypes mocks base method. +func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypes(arg0 *autoscaling.DescribeTerminationPolicyTypesInput) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypes", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeTerminationPolicyTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTerminationPolicyTypes indicates an expected call of DescribeTerminationPolicyTypes. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypes(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypes", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypes), arg0) +} + +// DescribeTerminationPolicyTypesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypesRequest(arg0 *autoscaling.DescribeTerminationPolicyTypesInput) (*request.Request, *autoscaling.DescribeTerminationPolicyTypesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeTerminationPolicyTypesOutput) + return ret0, ret1 +} + +// DescribeTerminationPolicyTypesRequest indicates an expected call of DescribeTerminationPolicyTypesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypesRequest), arg0) +} + +// DescribeTerminationPolicyTypesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeTerminationPolicyTypesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeTerminationPolicyTypesInput, arg2 ...request.Option) (*autoscaling.DescribeTerminationPolicyTypesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTerminationPolicyTypesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeTerminationPolicyTypesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTerminationPolicyTypesWithContext indicates an expected call of DescribeTerminationPolicyTypesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTerminationPolicyTypesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTerminationPolicyTypesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTerminationPolicyTypesWithContext), varargs...) +} + +// DescribeTrafficSources mocks base method. +func (m *MockAutoScalingAPI) DescribeTrafficSources(arg0 *autoscaling.DescribeTrafficSourcesInput) (*autoscaling.DescribeTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficSources", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficSources indicates an expected call of DescribeTrafficSources. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSources), arg0) +} + +// DescribeTrafficSourcesPages mocks base method. +func (m *MockAutoScalingAPI) DescribeTrafficSourcesPages(arg0 *autoscaling.DescribeTrafficSourcesInput, arg1 func(*autoscaling.DescribeTrafficSourcesOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficSourcesPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficSourcesPages indicates an expected call of DescribeTrafficSourcesPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesPages), arg0, arg1) +} + +// DescribeTrafficSourcesPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeTrafficSourcesPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeTrafficSourcesInput, arg2 func(*autoscaling.DescribeTrafficSourcesOutput, 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, "DescribeTrafficSourcesPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeTrafficSourcesPagesWithContext indicates an expected call of DescribeTrafficSourcesPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesPagesWithContext(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, "DescribeTrafficSourcesPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesPagesWithContext), varargs...) +} + +// DescribeTrafficSourcesRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeTrafficSourcesRequest(arg0 *autoscaling.DescribeTrafficSourcesInput) (*request.Request, *autoscaling.DescribeTrafficSourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeTrafficSourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeTrafficSourcesOutput) + return ret0, ret1 +} + +// DescribeTrafficSourcesRequest indicates an expected call of DescribeTrafficSourcesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesRequest), arg0) +} + +// DescribeTrafficSourcesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeTrafficSourcesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.DescribeTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeTrafficSourcesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeTrafficSourcesWithContext indicates an expected call of DescribeTrafficSourcesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeTrafficSourcesWithContext), varargs...) +} + +// DescribeWarmPool mocks base method. +func (m *MockAutoScalingAPI) DescribeWarmPool(arg0 *autoscaling.DescribeWarmPoolInput) (*autoscaling.DescribeWarmPoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeWarmPool", arg0) + ret0, _ := ret[0].(*autoscaling.DescribeWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeWarmPool indicates an expected call of DescribeWarmPool. +func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPool), arg0) +} + +// DescribeWarmPoolPages mocks base method. +func (m *MockAutoScalingAPI) DescribeWarmPoolPages(arg0 *autoscaling.DescribeWarmPoolInput, arg1 func(*autoscaling.DescribeWarmPoolOutput, bool) bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeWarmPoolPages", arg0, arg1) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeWarmPoolPages indicates an expected call of DescribeWarmPoolPages. +func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolPages(arg0, arg1 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolPages", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolPages), arg0, arg1) +} + +// DescribeWarmPoolPagesWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeWarmPoolPagesWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeWarmPoolInput, arg2 func(*autoscaling.DescribeWarmPoolOutput, 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, "DescribeWarmPoolPagesWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// DescribeWarmPoolPagesWithContext indicates an expected call of DescribeWarmPoolPagesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolPagesWithContext(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, "DescribeWarmPoolPagesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolPagesWithContext), varargs...) +} + +// DescribeWarmPoolRequest mocks base method. +func (m *MockAutoScalingAPI) DescribeWarmPoolRequest(arg0 *autoscaling.DescribeWarmPoolInput) (*request.Request, *autoscaling.DescribeWarmPoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DescribeWarmPoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DescribeWarmPoolOutput) + return ret0, ret1 +} + +// DescribeWarmPoolRequest indicates an expected call of DescribeWarmPoolRequest. +func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolRequest), arg0) +} + +// DescribeWarmPoolWithContext mocks base method. +func (m *MockAutoScalingAPI) DescribeWarmPoolWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeWarmPoolInput, arg2 ...request.Option) (*autoscaling.DescribeWarmPoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DescribeWarmPoolWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DescribeWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DescribeWarmPoolWithContext indicates an expected call of DescribeWarmPoolWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DescribeWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DescribeWarmPoolWithContext), varargs...) +} + +// DetachInstances mocks base method. +func (m *MockAutoScalingAPI) DetachInstances(arg0 *autoscaling.DetachInstancesInput) (*autoscaling.DetachInstancesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachInstances", arg0) + ret0, _ := ret[0].(*autoscaling.DetachInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachInstances indicates an expected call of DetachInstances. +func (mr *MockAutoScalingAPIMockRecorder) DetachInstances(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstances", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstances), arg0) +} + +// DetachInstancesRequest mocks base method. +func (m *MockAutoScalingAPI) DetachInstancesRequest(arg0 *autoscaling.DetachInstancesInput) (*request.Request, *autoscaling.DetachInstancesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachInstancesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DetachInstancesOutput) + return ret0, ret1 +} + +// DetachInstancesRequest indicates an expected call of DetachInstancesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DetachInstancesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstancesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstancesRequest), arg0) +} + +// DetachInstancesWithContext mocks base method. +func (m *MockAutoScalingAPI) DetachInstancesWithContext(arg0 aws.Context, arg1 *autoscaling.DetachInstancesInput, arg2 ...request.Option) (*autoscaling.DetachInstancesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachInstancesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DetachInstancesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachInstancesWithContext indicates an expected call of DetachInstancesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DetachInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInstancesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachInstancesWithContext), varargs...) +} + +// DetachLoadBalancerTargetGroups mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroups(arg0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroups", arg0) + ret0, _ := ret[0].(*autoscaling.DetachLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachLoadBalancerTargetGroups indicates an expected call of DetachLoadBalancerTargetGroups. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroups(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroups", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroups), arg0) +} + +// DetachLoadBalancerTargetGroupsRequest mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroupsRequest(arg0 *autoscaling.DetachLoadBalancerTargetGroupsInput) (*request.Request, *autoscaling.DetachLoadBalancerTargetGroupsOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroupsRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DetachLoadBalancerTargetGroupsOutput) + return ret0, ret1 +} + +// DetachLoadBalancerTargetGroupsRequest indicates an expected call of DetachLoadBalancerTargetGroupsRequest. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroupsRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroupsRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroupsRequest), arg0) +} + +// DetachLoadBalancerTargetGroupsWithContext mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancerTargetGroupsWithContext(arg0 aws.Context, arg1 *autoscaling.DetachLoadBalancerTargetGroupsInput, arg2 ...request.Option) (*autoscaling.DetachLoadBalancerTargetGroupsOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachLoadBalancerTargetGroupsWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DetachLoadBalancerTargetGroupsOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachLoadBalancerTargetGroupsWithContext indicates an expected call of DetachLoadBalancerTargetGroupsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancerTargetGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancerTargetGroupsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancerTargetGroupsWithContext), varargs...) +} + +// DetachLoadBalancers mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancers(arg0 *autoscaling.DetachLoadBalancersInput) (*autoscaling.DetachLoadBalancersOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachLoadBalancers", arg0) + ret0, _ := ret[0].(*autoscaling.DetachLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachLoadBalancers indicates an expected call of DetachLoadBalancers. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancers(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancers", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancers), arg0) +} + +// DetachLoadBalancersRequest mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancersRequest(arg0 *autoscaling.DetachLoadBalancersInput) (*request.Request, *autoscaling.DetachLoadBalancersOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachLoadBalancersRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DetachLoadBalancersOutput) + return ret0, ret1 +} + +// DetachLoadBalancersRequest indicates an expected call of DetachLoadBalancersRequest. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancersRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancersRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancersRequest), arg0) +} + +// DetachLoadBalancersWithContext mocks base method. +func (m *MockAutoScalingAPI) DetachLoadBalancersWithContext(arg0 aws.Context, arg1 *autoscaling.DetachLoadBalancersInput, arg2 ...request.Option) (*autoscaling.DetachLoadBalancersOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachLoadBalancersWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DetachLoadBalancersOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachLoadBalancersWithContext indicates an expected call of DetachLoadBalancersWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DetachLoadBalancersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachLoadBalancersWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachLoadBalancersWithContext), varargs...) +} + +// DetachTrafficSources mocks base method. +func (m *MockAutoScalingAPI) DetachTrafficSources(arg0 *autoscaling.DetachTrafficSourcesInput) (*autoscaling.DetachTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachTrafficSources", arg0) + ret0, _ := ret[0].(*autoscaling.DetachTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachTrafficSources indicates an expected call of DetachTrafficSources. +func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSources(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSources", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSources), arg0) +} + +// DetachTrafficSourcesRequest mocks base method. +func (m *MockAutoScalingAPI) DetachTrafficSourcesRequest(arg0 *autoscaling.DetachTrafficSourcesInput) (*request.Request, *autoscaling.DetachTrafficSourcesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DetachTrafficSourcesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DetachTrafficSourcesOutput) + return ret0, ret1 +} + +// DetachTrafficSourcesRequest indicates an expected call of DetachTrafficSourcesRequest. +func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSourcesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSourcesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSourcesRequest), arg0) +} + +// DetachTrafficSourcesWithContext mocks base method. +func (m *MockAutoScalingAPI) DetachTrafficSourcesWithContext(arg0 aws.Context, arg1 *autoscaling.DetachTrafficSourcesInput, arg2 ...request.Option) (*autoscaling.DetachTrafficSourcesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DetachTrafficSourcesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DetachTrafficSourcesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DetachTrafficSourcesWithContext indicates an expected call of DetachTrafficSourcesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DetachTrafficSourcesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachTrafficSourcesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DetachTrafficSourcesWithContext), varargs...) +} + +// DisableMetricsCollection mocks base method. +func (m *MockAutoScalingAPI) DisableMetricsCollection(arg0 *autoscaling.DisableMetricsCollectionInput) (*autoscaling.DisableMetricsCollectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableMetricsCollection", arg0) + ret0, _ := ret[0].(*autoscaling.DisableMetricsCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableMetricsCollection indicates an expected call of DisableMetricsCollection. +func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollection", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollection), arg0) +} + +// DisableMetricsCollectionRequest mocks base method. +func (m *MockAutoScalingAPI) DisableMetricsCollectionRequest(arg0 *autoscaling.DisableMetricsCollectionInput) (*request.Request, *autoscaling.DisableMetricsCollectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "DisableMetricsCollectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.DisableMetricsCollectionOutput) + return ret0, ret1 +} + +// DisableMetricsCollectionRequest indicates an expected call of DisableMetricsCollectionRequest. +func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollectionRequest), arg0) +} + +// DisableMetricsCollectionWithContext mocks base method. +func (m *MockAutoScalingAPI) DisableMetricsCollectionWithContext(arg0 aws.Context, arg1 *autoscaling.DisableMetricsCollectionInput, arg2 ...request.Option) (*autoscaling.DisableMetricsCollectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "DisableMetricsCollectionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.DisableMetricsCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// DisableMetricsCollectionWithContext indicates an expected call of DisableMetricsCollectionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) DisableMetricsCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableMetricsCollectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).DisableMetricsCollectionWithContext), varargs...) +} + +// EnableMetricsCollection mocks base method. +func (m *MockAutoScalingAPI) EnableMetricsCollection(arg0 *autoscaling.EnableMetricsCollectionInput) (*autoscaling.EnableMetricsCollectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableMetricsCollection", arg0) + ret0, _ := ret[0].(*autoscaling.EnableMetricsCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableMetricsCollection indicates an expected call of EnableMetricsCollection. +func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollection", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollection), arg0) +} + +// EnableMetricsCollectionRequest mocks base method. +func (m *MockAutoScalingAPI) EnableMetricsCollectionRequest(arg0 *autoscaling.EnableMetricsCollectionInput) (*request.Request, *autoscaling.EnableMetricsCollectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnableMetricsCollectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.EnableMetricsCollectionOutput) + return ret0, ret1 +} + +// EnableMetricsCollectionRequest indicates an expected call of EnableMetricsCollectionRequest. +func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollectionRequest), arg0) +} + +// EnableMetricsCollectionWithContext mocks base method. +func (m *MockAutoScalingAPI) EnableMetricsCollectionWithContext(arg0 aws.Context, arg1 *autoscaling.EnableMetricsCollectionInput, arg2 ...request.Option) (*autoscaling.EnableMetricsCollectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnableMetricsCollectionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.EnableMetricsCollectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnableMetricsCollectionWithContext indicates an expected call of EnableMetricsCollectionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) EnableMetricsCollectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableMetricsCollectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnableMetricsCollectionWithContext), varargs...) +} + +// EnterStandby mocks base method. +func (m *MockAutoScalingAPI) EnterStandby(arg0 *autoscaling.EnterStandbyInput) (*autoscaling.EnterStandbyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnterStandby", arg0) + ret0, _ := ret[0].(*autoscaling.EnterStandbyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnterStandby indicates an expected call of EnterStandby. +func (mr *MockAutoScalingAPIMockRecorder) EnterStandby(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandby", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandby), arg0) +} + +// EnterStandbyRequest mocks base method. +func (m *MockAutoScalingAPI) EnterStandbyRequest(arg0 *autoscaling.EnterStandbyInput) (*request.Request, *autoscaling.EnterStandbyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "EnterStandbyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.EnterStandbyOutput) + return ret0, ret1 +} + +// EnterStandbyRequest indicates an expected call of EnterStandbyRequest. +func (mr *MockAutoScalingAPIMockRecorder) EnterStandbyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandbyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandbyRequest), arg0) +} + +// EnterStandbyWithContext mocks base method. +func (m *MockAutoScalingAPI) EnterStandbyWithContext(arg0 aws.Context, arg1 *autoscaling.EnterStandbyInput, arg2 ...request.Option) (*autoscaling.EnterStandbyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "EnterStandbyWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.EnterStandbyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// EnterStandbyWithContext indicates an expected call of EnterStandbyWithContext. +func (mr *MockAutoScalingAPIMockRecorder) EnterStandbyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnterStandbyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).EnterStandbyWithContext), varargs...) +} + +// ExecutePolicy mocks base method. +func (m *MockAutoScalingAPI) ExecutePolicy(arg0 *autoscaling.ExecutePolicyInput) (*autoscaling.ExecutePolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExecutePolicy", arg0) + ret0, _ := ret[0].(*autoscaling.ExecutePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExecutePolicy indicates an expected call of ExecutePolicy. +func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicy), arg0) +} + +// ExecutePolicyRequest mocks base method. +func (m *MockAutoScalingAPI) ExecutePolicyRequest(arg0 *autoscaling.ExecutePolicyInput) (*request.Request, *autoscaling.ExecutePolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExecutePolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.ExecutePolicyOutput) + return ret0, ret1 +} + +// ExecutePolicyRequest indicates an expected call of ExecutePolicyRequest. +func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicyRequest), arg0) +} + +// ExecutePolicyWithContext mocks base method. +func (m *MockAutoScalingAPI) ExecutePolicyWithContext(arg0 aws.Context, arg1 *autoscaling.ExecutePolicyInput, arg2 ...request.Option) (*autoscaling.ExecutePolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExecutePolicyWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.ExecutePolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExecutePolicyWithContext indicates an expected call of ExecutePolicyWithContext. +func (mr *MockAutoScalingAPIMockRecorder) ExecutePolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecutePolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExecutePolicyWithContext), varargs...) +} + +// ExitStandby mocks base method. +func (m *MockAutoScalingAPI) ExitStandby(arg0 *autoscaling.ExitStandbyInput) (*autoscaling.ExitStandbyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExitStandby", arg0) + ret0, _ := ret[0].(*autoscaling.ExitStandbyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExitStandby indicates an expected call of ExitStandby. +func (mr *MockAutoScalingAPIMockRecorder) ExitStandby(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandby", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandby), arg0) +} + +// ExitStandbyRequest mocks base method. +func (m *MockAutoScalingAPI) ExitStandbyRequest(arg0 *autoscaling.ExitStandbyInput) (*request.Request, *autoscaling.ExitStandbyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ExitStandbyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.ExitStandbyOutput) + return ret0, ret1 +} + +// ExitStandbyRequest indicates an expected call of ExitStandbyRequest. +func (mr *MockAutoScalingAPIMockRecorder) ExitStandbyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandbyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandbyRequest), arg0) +} + +// ExitStandbyWithContext mocks base method. +func (m *MockAutoScalingAPI) ExitStandbyWithContext(arg0 aws.Context, arg1 *autoscaling.ExitStandbyInput, arg2 ...request.Option) (*autoscaling.ExitStandbyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ExitStandbyWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.ExitStandbyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ExitStandbyWithContext indicates an expected call of ExitStandbyWithContext. +func (mr *MockAutoScalingAPIMockRecorder) ExitStandbyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExitStandbyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ExitStandbyWithContext), varargs...) +} + +// GetPredictiveScalingForecast mocks base method. +func (m *MockAutoScalingAPI) GetPredictiveScalingForecast(arg0 *autoscaling.GetPredictiveScalingForecastInput) (*autoscaling.GetPredictiveScalingForecastOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPredictiveScalingForecast", arg0) + ret0, _ := ret[0].(*autoscaling.GetPredictiveScalingForecastOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPredictiveScalingForecast indicates an expected call of GetPredictiveScalingForecast. +func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecast(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecast", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecast), arg0) +} + +// GetPredictiveScalingForecastRequest mocks base method. +func (m *MockAutoScalingAPI) GetPredictiveScalingForecastRequest(arg0 *autoscaling.GetPredictiveScalingForecastInput) (*request.Request, *autoscaling.GetPredictiveScalingForecastOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPredictiveScalingForecastRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.GetPredictiveScalingForecastOutput) + return ret0, ret1 +} + +// GetPredictiveScalingForecastRequest indicates an expected call of GetPredictiveScalingForecastRequest. +func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecastRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecastRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecastRequest), arg0) +} + +// GetPredictiveScalingForecastWithContext mocks base method. +func (m *MockAutoScalingAPI) GetPredictiveScalingForecastWithContext(arg0 aws.Context, arg1 *autoscaling.GetPredictiveScalingForecastInput, arg2 ...request.Option) (*autoscaling.GetPredictiveScalingForecastOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GetPredictiveScalingForecastWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.GetPredictiveScalingForecastOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPredictiveScalingForecastWithContext indicates an expected call of GetPredictiveScalingForecastWithContext. +func (mr *MockAutoScalingAPIMockRecorder) GetPredictiveScalingForecastWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPredictiveScalingForecastWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).GetPredictiveScalingForecastWithContext), varargs...) +} + +// PutLifecycleHook mocks base method. +func (m *MockAutoScalingAPI) PutLifecycleHook(arg0 *autoscaling.PutLifecycleHookInput) (*autoscaling.PutLifecycleHookOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutLifecycleHook", arg0) + ret0, _ := ret[0].(*autoscaling.PutLifecycleHookOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutLifecycleHook indicates an expected call of PutLifecycleHook. +func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHook(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHook", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHook), arg0) +} + +// PutLifecycleHookRequest mocks base method. +func (m *MockAutoScalingAPI) PutLifecycleHookRequest(arg0 *autoscaling.PutLifecycleHookInput) (*request.Request, *autoscaling.PutLifecycleHookOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutLifecycleHookRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.PutLifecycleHookOutput) + return ret0, ret1 +} + +// PutLifecycleHookRequest indicates an expected call of PutLifecycleHookRequest. +func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHookRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHookRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHookRequest), arg0) +} + +// PutLifecycleHookWithContext mocks base method. +func (m *MockAutoScalingAPI) PutLifecycleHookWithContext(arg0 aws.Context, arg1 *autoscaling.PutLifecycleHookInput, arg2 ...request.Option) (*autoscaling.PutLifecycleHookOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutLifecycleHookWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.PutLifecycleHookOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutLifecycleHookWithContext indicates an expected call of PutLifecycleHookWithContext. +func (mr *MockAutoScalingAPIMockRecorder) PutLifecycleHookWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutLifecycleHookWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutLifecycleHookWithContext), varargs...) +} + +// PutNotificationConfiguration mocks base method. +func (m *MockAutoScalingAPI) PutNotificationConfiguration(arg0 *autoscaling.PutNotificationConfigurationInput) (*autoscaling.PutNotificationConfigurationOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutNotificationConfiguration", arg0) + ret0, _ := ret[0].(*autoscaling.PutNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutNotificationConfiguration indicates an expected call of PutNotificationConfiguration. +func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfiguration(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfiguration", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfiguration), arg0) +} + +// PutNotificationConfigurationRequest mocks base method. +func (m *MockAutoScalingAPI) PutNotificationConfigurationRequest(arg0 *autoscaling.PutNotificationConfigurationInput) (*request.Request, *autoscaling.PutNotificationConfigurationOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutNotificationConfigurationRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.PutNotificationConfigurationOutput) + return ret0, ret1 +} + +// PutNotificationConfigurationRequest indicates an expected call of PutNotificationConfigurationRequest. +func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfigurationRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfigurationRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfigurationRequest), arg0) +} + +// PutNotificationConfigurationWithContext mocks base method. +func (m *MockAutoScalingAPI) PutNotificationConfigurationWithContext(arg0 aws.Context, arg1 *autoscaling.PutNotificationConfigurationInput, arg2 ...request.Option) (*autoscaling.PutNotificationConfigurationOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutNotificationConfigurationWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.PutNotificationConfigurationOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutNotificationConfigurationWithContext indicates an expected call of PutNotificationConfigurationWithContext. +func (mr *MockAutoScalingAPIMockRecorder) PutNotificationConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutNotificationConfigurationWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutNotificationConfigurationWithContext), varargs...) +} + +// PutScalingPolicy mocks base method. +func (m *MockAutoScalingAPI) PutScalingPolicy(arg0 *autoscaling.PutScalingPolicyInput) (*autoscaling.PutScalingPolicyOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScalingPolicy", arg0) + ret0, _ := ret[0].(*autoscaling.PutScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScalingPolicy indicates an expected call of PutScalingPolicy. +func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicy(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicy", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicy), arg0) +} + +// PutScalingPolicyRequest mocks base method. +func (m *MockAutoScalingAPI) PutScalingPolicyRequest(arg0 *autoscaling.PutScalingPolicyInput) (*request.Request, *autoscaling.PutScalingPolicyOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScalingPolicyRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.PutScalingPolicyOutput) + return ret0, ret1 +} + +// PutScalingPolicyRequest indicates an expected call of PutScalingPolicyRequest. +func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicyRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicyRequest), arg0) +} + +// PutScalingPolicyWithContext mocks base method. +func (m *MockAutoScalingAPI) PutScalingPolicyWithContext(arg0 aws.Context, arg1 *autoscaling.PutScalingPolicyInput, arg2 ...request.Option) (*autoscaling.PutScalingPolicyOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutScalingPolicyWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.PutScalingPolicyOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScalingPolicyWithContext indicates an expected call of PutScalingPolicyWithContext. +func (mr *MockAutoScalingAPIMockRecorder) PutScalingPolicyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScalingPolicyWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScalingPolicyWithContext), varargs...) +} + +// PutScheduledUpdateGroupAction mocks base method. +func (m *MockAutoScalingAPI) PutScheduledUpdateGroupAction(arg0 *autoscaling.PutScheduledUpdateGroupActionInput) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScheduledUpdateGroupAction", arg0) + ret0, _ := ret[0].(*autoscaling.PutScheduledUpdateGroupActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScheduledUpdateGroupAction indicates an expected call of PutScheduledUpdateGroupAction. +func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupAction(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupAction", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupAction), arg0) +} + +// PutScheduledUpdateGroupActionRequest mocks base method. +func (m *MockAutoScalingAPI) PutScheduledUpdateGroupActionRequest(arg0 *autoscaling.PutScheduledUpdateGroupActionInput) (*request.Request, *autoscaling.PutScheduledUpdateGroupActionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutScheduledUpdateGroupActionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.PutScheduledUpdateGroupActionOutput) + return ret0, ret1 +} + +// PutScheduledUpdateGroupActionRequest indicates an expected call of PutScheduledUpdateGroupActionRequest. +func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupActionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupActionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupActionRequest), arg0) +} + +// PutScheduledUpdateGroupActionWithContext mocks base method. +func (m *MockAutoScalingAPI) PutScheduledUpdateGroupActionWithContext(arg0 aws.Context, arg1 *autoscaling.PutScheduledUpdateGroupActionInput, arg2 ...request.Option) (*autoscaling.PutScheduledUpdateGroupActionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutScheduledUpdateGroupActionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.PutScheduledUpdateGroupActionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutScheduledUpdateGroupActionWithContext indicates an expected call of PutScheduledUpdateGroupActionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) PutScheduledUpdateGroupActionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutScheduledUpdateGroupActionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutScheduledUpdateGroupActionWithContext), varargs...) +} + +// PutWarmPool mocks base method. +func (m *MockAutoScalingAPI) PutWarmPool(arg0 *autoscaling.PutWarmPoolInput) (*autoscaling.PutWarmPoolOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutWarmPool", arg0) + ret0, _ := ret[0].(*autoscaling.PutWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutWarmPool indicates an expected call of PutWarmPool. +func (mr *MockAutoScalingAPIMockRecorder) PutWarmPool(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPool", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPool), arg0) +} + +// PutWarmPoolRequest mocks base method. +func (m *MockAutoScalingAPI) PutWarmPoolRequest(arg0 *autoscaling.PutWarmPoolInput) (*request.Request, *autoscaling.PutWarmPoolOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PutWarmPoolRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.PutWarmPoolOutput) + return ret0, ret1 +} + +// PutWarmPoolRequest indicates an expected call of PutWarmPoolRequest. +func (mr *MockAutoScalingAPIMockRecorder) PutWarmPoolRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPoolRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPoolRequest), arg0) +} + +// PutWarmPoolWithContext mocks base method. +func (m *MockAutoScalingAPI) PutWarmPoolWithContext(arg0 aws.Context, arg1 *autoscaling.PutWarmPoolInput, arg2 ...request.Option) (*autoscaling.PutWarmPoolOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "PutWarmPoolWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.PutWarmPoolOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PutWarmPoolWithContext indicates an expected call of PutWarmPoolWithContext. +func (mr *MockAutoScalingAPIMockRecorder) PutWarmPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutWarmPoolWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).PutWarmPoolWithContext), varargs...) +} + +// RecordLifecycleActionHeartbeat mocks base method. +func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeat(arg0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeat", arg0) + ret0, _ := ret[0].(*autoscaling.RecordLifecycleActionHeartbeatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RecordLifecycleActionHeartbeat indicates an expected call of RecordLifecycleActionHeartbeat. +func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeat(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeat", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeat), arg0) +} + +// RecordLifecycleActionHeartbeatRequest mocks base method. +func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeatRequest(arg0 *autoscaling.RecordLifecycleActionHeartbeatInput) (*request.Request, *autoscaling.RecordLifecycleActionHeartbeatOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeatRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.RecordLifecycleActionHeartbeatOutput) + return ret0, ret1 +} + +// RecordLifecycleActionHeartbeatRequest indicates an expected call of RecordLifecycleActionHeartbeatRequest. +func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeatRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeatRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeatRequest), arg0) +} + +// RecordLifecycleActionHeartbeatWithContext mocks base method. +func (m *MockAutoScalingAPI) RecordLifecycleActionHeartbeatWithContext(arg0 aws.Context, arg1 *autoscaling.RecordLifecycleActionHeartbeatInput, arg2 ...request.Option) (*autoscaling.RecordLifecycleActionHeartbeatOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RecordLifecycleActionHeartbeatWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.RecordLifecycleActionHeartbeatOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RecordLifecycleActionHeartbeatWithContext indicates an expected call of RecordLifecycleActionHeartbeatWithContext. +func (mr *MockAutoScalingAPIMockRecorder) RecordLifecycleActionHeartbeatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordLifecycleActionHeartbeatWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).RecordLifecycleActionHeartbeatWithContext), varargs...) +} + +// ResumeProcesses mocks base method. +func (m *MockAutoScalingAPI) ResumeProcesses(arg0 *autoscaling.ScalingProcessQuery) (*autoscaling.ResumeProcessesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResumeProcesses", arg0) + ret0, _ := ret[0].(*autoscaling.ResumeProcessesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResumeProcesses indicates an expected call of ResumeProcesses. +func (mr *MockAutoScalingAPIMockRecorder) ResumeProcesses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcesses), arg0) +} + +// ResumeProcessesRequest mocks base method. +func (m *MockAutoScalingAPI) ResumeProcessesRequest(arg0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.ResumeProcessesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ResumeProcessesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.ResumeProcessesOutput) + return ret0, ret1 +} + +// ResumeProcessesRequest indicates an expected call of ResumeProcessesRequest. +func (mr *MockAutoScalingAPIMockRecorder) ResumeProcessesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcessesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcessesRequest), arg0) +} + +// ResumeProcessesWithContext mocks base method. +func (m *MockAutoScalingAPI) ResumeProcessesWithContext(arg0 aws.Context, arg1 *autoscaling.ScalingProcessQuery, arg2 ...request.Option) (*autoscaling.ResumeProcessesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ResumeProcessesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.ResumeProcessesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ResumeProcessesWithContext indicates an expected call of ResumeProcessesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) ResumeProcessesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeProcessesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).ResumeProcessesWithContext), varargs...) +} + +// RollbackInstanceRefresh mocks base method. +func (m *MockAutoScalingAPI) RollbackInstanceRefresh(arg0 *autoscaling.RollbackInstanceRefreshInput) (*autoscaling.RollbackInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RollbackInstanceRefresh", arg0) + ret0, _ := ret[0].(*autoscaling.RollbackInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RollbackInstanceRefresh indicates an expected call of RollbackInstanceRefresh. +func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefresh(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefresh), arg0) +} + +// RollbackInstanceRefreshRequest mocks base method. +func (m *MockAutoScalingAPI) RollbackInstanceRefreshRequest(arg0 *autoscaling.RollbackInstanceRefreshInput) (*request.Request, *autoscaling.RollbackInstanceRefreshOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "RollbackInstanceRefreshRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.RollbackInstanceRefreshOutput) + return ret0, ret1 +} + +// RollbackInstanceRefreshRequest indicates an expected call of RollbackInstanceRefreshRequest. +func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefreshRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefreshRequest), arg0) +} + +// RollbackInstanceRefreshWithContext mocks base method. +func (m *MockAutoScalingAPI) RollbackInstanceRefreshWithContext(arg0 aws.Context, arg1 *autoscaling.RollbackInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.RollbackInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RollbackInstanceRefreshWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.RollbackInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RollbackInstanceRefreshWithContext indicates an expected call of RollbackInstanceRefreshWithContext. +func (mr *MockAutoScalingAPIMockRecorder) RollbackInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollbackInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).RollbackInstanceRefreshWithContext), varargs...) +} + +// SetDesiredCapacity mocks base method. +func (m *MockAutoScalingAPI) SetDesiredCapacity(arg0 *autoscaling.SetDesiredCapacityInput) (*autoscaling.SetDesiredCapacityOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDesiredCapacity", arg0) + ret0, _ := ret[0].(*autoscaling.SetDesiredCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDesiredCapacity indicates an expected call of SetDesiredCapacity. +func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacity(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacity", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacity), arg0) +} + +// SetDesiredCapacityRequest mocks base method. +func (m *MockAutoScalingAPI) SetDesiredCapacityRequest(arg0 *autoscaling.SetDesiredCapacityInput) (*request.Request, *autoscaling.SetDesiredCapacityOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetDesiredCapacityRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.SetDesiredCapacityOutput) + return ret0, ret1 +} + +// SetDesiredCapacityRequest indicates an expected call of SetDesiredCapacityRequest. +func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacityRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacityRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacityRequest), arg0) +} + +// SetDesiredCapacityWithContext mocks base method. +func (m *MockAutoScalingAPI) SetDesiredCapacityWithContext(arg0 aws.Context, arg1 *autoscaling.SetDesiredCapacityInput, arg2 ...request.Option) (*autoscaling.SetDesiredCapacityOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetDesiredCapacityWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.SetDesiredCapacityOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetDesiredCapacityWithContext indicates an expected call of SetDesiredCapacityWithContext. +func (mr *MockAutoScalingAPIMockRecorder) SetDesiredCapacityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDesiredCapacityWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetDesiredCapacityWithContext), varargs...) +} + +// SetInstanceHealth mocks base method. +func (m *MockAutoScalingAPI) SetInstanceHealth(arg0 *autoscaling.SetInstanceHealthInput) (*autoscaling.SetInstanceHealthOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetInstanceHealth", arg0) + ret0, _ := ret[0].(*autoscaling.SetInstanceHealthOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetInstanceHealth indicates an expected call of SetInstanceHealth. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealth(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealth", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealth), arg0) +} + +// SetInstanceHealthRequest mocks base method. +func (m *MockAutoScalingAPI) SetInstanceHealthRequest(arg0 *autoscaling.SetInstanceHealthInput) (*request.Request, *autoscaling.SetInstanceHealthOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetInstanceHealthRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.SetInstanceHealthOutput) + return ret0, ret1 +} + +// SetInstanceHealthRequest indicates an expected call of SetInstanceHealthRequest. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealthRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealthRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealthRequest), arg0) +} + +// SetInstanceHealthWithContext mocks base method. +func (m *MockAutoScalingAPI) SetInstanceHealthWithContext(arg0 aws.Context, arg1 *autoscaling.SetInstanceHealthInput, arg2 ...request.Option) (*autoscaling.SetInstanceHealthOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetInstanceHealthWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.SetInstanceHealthOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetInstanceHealthWithContext indicates an expected call of SetInstanceHealthWithContext. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceHealthWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceHealthWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceHealthWithContext), varargs...) +} + +// SetInstanceProtection mocks base method. +func (m *MockAutoScalingAPI) SetInstanceProtection(arg0 *autoscaling.SetInstanceProtectionInput) (*autoscaling.SetInstanceProtectionOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetInstanceProtection", arg0) + ret0, _ := ret[0].(*autoscaling.SetInstanceProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetInstanceProtection indicates an expected call of SetInstanceProtection. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtection(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtection", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtection), arg0) +} + +// SetInstanceProtectionRequest mocks base method. +func (m *MockAutoScalingAPI) SetInstanceProtectionRequest(arg0 *autoscaling.SetInstanceProtectionInput) (*request.Request, *autoscaling.SetInstanceProtectionOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetInstanceProtectionRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.SetInstanceProtectionOutput) + return ret0, ret1 +} + +// SetInstanceProtectionRequest indicates an expected call of SetInstanceProtectionRequest. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtectionRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtectionRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtectionRequest), arg0) +} + +// SetInstanceProtectionWithContext mocks base method. +func (m *MockAutoScalingAPI) SetInstanceProtectionWithContext(arg0 aws.Context, arg1 *autoscaling.SetInstanceProtectionInput, arg2 ...request.Option) (*autoscaling.SetInstanceProtectionOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SetInstanceProtectionWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.SetInstanceProtectionOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetInstanceProtectionWithContext indicates an expected call of SetInstanceProtectionWithContext. +func (mr *MockAutoScalingAPIMockRecorder) SetInstanceProtectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceProtectionWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SetInstanceProtectionWithContext), varargs...) +} + +// StartInstanceRefresh mocks base method. +func (m *MockAutoScalingAPI) StartInstanceRefresh(arg0 *autoscaling.StartInstanceRefreshInput) (*autoscaling.StartInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartInstanceRefresh", arg0) + ret0, _ := ret[0].(*autoscaling.StartInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartInstanceRefresh indicates an expected call of StartInstanceRefresh. +func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefresh(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefresh", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefresh), arg0) +} + +// StartInstanceRefreshRequest mocks base method. +func (m *MockAutoScalingAPI) StartInstanceRefreshRequest(arg0 *autoscaling.StartInstanceRefreshInput) (*request.Request, *autoscaling.StartInstanceRefreshOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "StartInstanceRefreshRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.StartInstanceRefreshOutput) + return ret0, ret1 +} + +// StartInstanceRefreshRequest indicates an expected call of StartInstanceRefreshRequest. +func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefreshRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefreshRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefreshRequest), arg0) +} + +// StartInstanceRefreshWithContext mocks base method. +func (m *MockAutoScalingAPI) StartInstanceRefreshWithContext(arg0 aws.Context, arg1 *autoscaling.StartInstanceRefreshInput, arg2 ...request.Option) (*autoscaling.StartInstanceRefreshOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "StartInstanceRefreshWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.StartInstanceRefreshOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// StartInstanceRefreshWithContext indicates an expected call of StartInstanceRefreshWithContext. +func (mr *MockAutoScalingAPIMockRecorder) StartInstanceRefreshWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstanceRefreshWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).StartInstanceRefreshWithContext), varargs...) +} + +// SuspendProcesses mocks base method. +func (m *MockAutoScalingAPI) SuspendProcesses(arg0 *autoscaling.ScalingProcessQuery) (*autoscaling.SuspendProcessesOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SuspendProcesses", arg0) + ret0, _ := ret[0].(*autoscaling.SuspendProcessesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SuspendProcesses indicates an expected call of SuspendProcesses. +func (mr *MockAutoScalingAPIMockRecorder) SuspendProcesses(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcesses", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcesses), arg0) +} + +// SuspendProcessesRequest mocks base method. +func (m *MockAutoScalingAPI) SuspendProcessesRequest(arg0 *autoscaling.ScalingProcessQuery) (*request.Request, *autoscaling.SuspendProcessesOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SuspendProcessesRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.SuspendProcessesOutput) + return ret0, ret1 +} + +// SuspendProcessesRequest indicates an expected call of SuspendProcessesRequest. +func (mr *MockAutoScalingAPIMockRecorder) SuspendProcessesRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcessesRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcessesRequest), arg0) +} + +// SuspendProcessesWithContext mocks base method. +func (m *MockAutoScalingAPI) SuspendProcessesWithContext(arg0 aws.Context, arg1 *autoscaling.ScalingProcessQuery, arg2 ...request.Option) (*autoscaling.SuspendProcessesOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "SuspendProcessesWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.SuspendProcessesOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SuspendProcessesWithContext indicates an expected call of SuspendProcessesWithContext. +func (mr *MockAutoScalingAPIMockRecorder) SuspendProcessesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SuspendProcessesWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).SuspendProcessesWithContext), varargs...) +} + +// TerminateInstanceInAutoScalingGroup mocks base method. +func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroup(arg0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroup", arg0) + ret0, _ := ret[0].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateInstanceInAutoScalingGroup indicates an expected call of TerminateInstanceInAutoScalingGroup. +func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroup), arg0) +} + +// TerminateInstanceInAutoScalingGroupRequest mocks base method. +func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroupRequest(arg0 *autoscaling.TerminateInstanceInAutoScalingGroupInput) (*request.Request, *autoscaling.TerminateInstanceInAutoScalingGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput) + return ret0, ret1 +} + +// TerminateInstanceInAutoScalingGroupRequest indicates an expected call of TerminateInstanceInAutoScalingGroupRequest. +func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroupRequest), arg0) +} + +// TerminateInstanceInAutoScalingGroupWithContext mocks base method. +func (m *MockAutoScalingAPI) TerminateInstanceInAutoScalingGroupWithContext(arg0 aws.Context, arg1 *autoscaling.TerminateInstanceInAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.TerminateInstanceInAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "TerminateInstanceInAutoScalingGroupWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.TerminateInstanceInAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// TerminateInstanceInAutoScalingGroupWithContext indicates an expected call of TerminateInstanceInAutoScalingGroupWithContext. +func (mr *MockAutoScalingAPIMockRecorder) TerminateInstanceInAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstanceInAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).TerminateInstanceInAutoScalingGroupWithContext), varargs...) +} + +// UpdateAutoScalingGroup mocks base method. +func (m *MockAutoScalingAPI) UpdateAutoScalingGroup(arg0 *autoscaling.UpdateAutoScalingGroupInput) (*autoscaling.UpdateAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAutoScalingGroup", arg0) + ret0, _ := ret[0].(*autoscaling.UpdateAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAutoScalingGroup indicates an expected call of UpdateAutoScalingGroup. +func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroup(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroup", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroup), arg0) +} + +// UpdateAutoScalingGroupRequest mocks base method. +func (m *MockAutoScalingAPI) UpdateAutoScalingGroupRequest(arg0 *autoscaling.UpdateAutoScalingGroupInput) (*request.Request, *autoscaling.UpdateAutoScalingGroupOutput) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdateAutoScalingGroupRequest", arg0) + ret0, _ := ret[0].(*request.Request) + ret1, _ := ret[1].(*autoscaling.UpdateAutoScalingGroupOutput) + return ret0, ret1 +} + +// UpdateAutoScalingGroupRequest indicates an expected call of UpdateAutoScalingGroupRequest. +func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroupRequest(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroupRequest", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroupRequest), arg0) +} + +// UpdateAutoScalingGroupWithContext mocks base method. +func (m *MockAutoScalingAPI) UpdateAutoScalingGroupWithContext(arg0 aws.Context, arg1 *autoscaling.UpdateAutoScalingGroupInput, arg2 ...request.Option) (*autoscaling.UpdateAutoScalingGroupOutput, error) { + m.ctrl.T.Helper() + varargs := []interface{}{arg0, arg1} + for _, a := range arg2 { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UpdateAutoScalingGroupWithContext", varargs...) + ret0, _ := ret[0].(*autoscaling.UpdateAutoScalingGroupOutput) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdateAutoScalingGroupWithContext indicates an expected call of UpdateAutoScalingGroupWithContext. +func (mr *MockAutoScalingAPIMockRecorder) UpdateAutoScalingGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAutoScalingGroupWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).UpdateAutoScalingGroupWithContext), varargs...) +} + +// WaitUntilGroupExists mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupExists(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilGroupExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupExists indicates an expected call of WaitUntilGroupExists. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupExists", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupExists), arg0) +} + +// WaitUntilGroupExistsWithContext mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupExistsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, 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, "WaitUntilGroupExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupExistsWithContext indicates an expected call of WaitUntilGroupExistsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupExistsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupExistsWithContext), varargs...) +} + +// WaitUntilGroupInService mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupInService(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilGroupInService", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupInService indicates an expected call of WaitUntilGroupInService. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupInService(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupInService", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupInService), arg0) +} + +// WaitUntilGroupInServiceWithContext mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupInServiceWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, 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, "WaitUntilGroupInServiceWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupInServiceWithContext indicates an expected call of WaitUntilGroupInServiceWithContext. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupInServiceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupInServiceWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupInServiceWithContext), varargs...) +} + +// WaitUntilGroupNotExists mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupNotExists(arg0 *autoscaling.DescribeAutoScalingGroupsInput) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WaitUntilGroupNotExists", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupNotExists indicates an expected call of WaitUntilGroupNotExists. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupNotExists(arg0 interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupNotExists", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupNotExists), arg0) +} + +// WaitUntilGroupNotExistsWithContext mocks base method. +func (m *MockAutoScalingAPI) WaitUntilGroupNotExistsWithContext(arg0 aws.Context, arg1 *autoscaling.DescribeAutoScalingGroupsInput, 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, "WaitUntilGroupNotExistsWithContext", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// WaitUntilGroupNotExistsWithContext indicates an expected call of WaitUntilGroupNotExistsWithContext. +func (mr *MockAutoScalingAPIMockRecorder) WaitUntilGroupNotExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { + mr.mock.ctrl.T.Helper() + varargs := append([]interface{}{arg0, arg1}, arg2...) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilGroupNotExistsWithContext", reflect.TypeOf((*MockAutoScalingAPI)(nil).WaitUntilGroupNotExistsWithContext), varargs...) +} diff --git a/resources/autoscaling-launch-configurations_mock_test.go b/resources/autoscaling-launch-configurations_mock_test.go new file mode 100644 index 00000000..7698437f --- /dev/null +++ b/resources/autoscaling-launch-configurations_mock_test.go @@ -0,0 +1,91 @@ +package resources + +import ( + "context" + "testing" + "time" + + "github.com/golang/mock/gomock" + "github.com/gotidy/ptr" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/autoscaling" + + "github.com/ekristen/aws-nuke/v3/mocks/mock_autoscalingiface" + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +func Test_Mock_AutoScalingLaunchConfiguration_List(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockSvc := mock_autoscalingiface.NewMockAutoScalingAPI(ctrl) + + mockSvc.EXPECT(). + DescribeLaunchConfigurationsPages(gomock.Eq(&autoscaling.DescribeLaunchConfigurationsInput{}), gomock.Any()). + Do(func(input *autoscaling.DescribeLaunchConfigurationsInput, + fn func(res *autoscaling.DescribeLaunchConfigurationsOutput, lastPage bool) bool) { + fn(&autoscaling.DescribeLaunchConfigurationsOutput{ + LaunchConfigurations: []*autoscaling.LaunchConfiguration{ + { + LaunchConfigurationName: ptr.String("foo"), + CreatedTime: ptr.Time(time.Now()), + }, + }, + }, true) + }). + Return(nil) + + lister := AutoScalingLaunchConfigurationLister{ + mockSvc: mockSvc, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession()), + }) + + a.Nil(err) + a.Len(resources, 1) +} + +func Test_Mock_AutoScalingLaunchConfiguration_Remove(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockSvc := mock_autoscalingiface.NewMockAutoScalingAPI(ctrl) + + mockSvc.EXPECT().DeleteLaunchConfiguration(gomock.Eq(&autoscaling.DeleteLaunchConfigurationInput{ + LaunchConfigurationName: ptr.String("foo"), + })).Return(&autoscaling.DeleteLaunchConfigurationOutput{}, nil) + + resource := AutoScalingLaunchConfiguration{ + svc: mockSvc, + Name: ptr.String("foo"), + } + + err := resource.Remove(context.TODO()) + a.Nil(err) +} + +func Test_Mock_AutoScalingLaunchConfiguration_Properties(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockSvc := mock_autoscalingiface.NewMockAutoScalingAPI(ctrl) + + resource := AutoScalingLaunchConfiguration{ + svc: mockSvc, + Name: ptr.String("foo"), + } + + properties := resource.Properties() + + a.Equal("foo", properties.Get("Name")) +} diff --git a/resources/autoscaling-lifecycle-hooks_mock_test.go b/resources/autoscaling-lifecycle-hooks_mock_test.go new file mode 100644 index 00000000..6b791c17 --- /dev/null +++ b/resources/autoscaling-lifecycle-hooks_mock_test.go @@ -0,0 +1,95 @@ +package resources + +import ( + "context" + "testing" + + "github.com/golang/mock/gomock" + "github.com/stretchr/testify/assert" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/session" + "github.com/aws/aws-sdk-go/service/autoscaling" + + "github.com/ekristen/aws-nuke/v3/mocks/mock_autoscalingiface" + "github.com/ekristen/aws-nuke/v3/pkg/nuke" +) + +func Test_Mock_AutoScalingLifeCycleHook_List(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockSvc := mock_autoscalingiface.NewMockAutoScalingAPI(ctrl) + + mockSvc.EXPECT().DescribeAutoScalingGroups(gomock.Eq(&autoscaling.DescribeAutoScalingGroupsInput{})). + Return(&autoscaling.DescribeAutoScalingGroupsOutput{ + AutoScalingGroups: []*autoscaling.Group{ + { + AutoScalingGroupName: aws.String("foobar-group"), + }, + }, + }, nil) + + mockSvc.EXPECT().DescribeLifecycleHooks(gomock.Eq(&autoscaling.DescribeLifecycleHooksInput{ + AutoScalingGroupName: aws.String("foobar-group"), + })). + Return(&autoscaling.DescribeLifecycleHooksOutput{ + LifecycleHooks: []*autoscaling.LifecycleHook{ + { + LifecycleHookName: aws.String("foobar-hook"), + AutoScalingGroupName: aws.String("foobar-group"), + }, + }, + }, nil) + + lister := AutoScalingLifecycleHookLister{ + mockSvc: mockSvc, + } + + resources, err := lister.List(context.TODO(), &nuke.ListerOpts{ + Region: &nuke.Region{ + Name: "us-east-2", + }, + Session: session.Must(session.NewSession(&aws.Config{})), + }) + + a.NoError(err) + a.Len(resources, 1) +} + +func Test_Mock_AutoScalingLifeCycleHook_Remove(t *testing.T) { + a := assert.New(t) + ctrl := gomock.NewController(t) + defer ctrl.Finish() + + mockSvc := mock_autoscalingiface.NewMockAutoScalingAPI(ctrl) + + mockSvc.EXPECT().DeleteLifecycleHook(gomock.Eq(&autoscaling.DeleteLifecycleHookInput{ + AutoScalingGroupName: aws.String("foobar-group"), + LifecycleHookName: aws.String("foobar-hook"), + })).Return(&autoscaling.DeleteLifecycleHookOutput{}, nil) + + resource := AutoScalingLifecycleHook{ + svc: mockSvc, + Name: aws.String("foobar-hook"), + GroupName: aws.String("foobar-group"), + } + + err := resource.Remove(context.TODO()) + a.NoError(err) +} + +func Test_Mock_AutoScalingLifeCycleHook_Properties(t *testing.T) { + a := assert.New(t) + + resource := AutoScalingLifecycleHook{ + Name: aws.String("foobar-hook"), + GroupName: aws.String("foobar-group"), + } + + props := resource.Properties() + + a.Equal("foobar-hook", props.Get("Name")) + a.Equal("foobar-group", props.Get("GroupName")) +} diff --git a/resources/autoscaling_mock_test.go b/resources/autoscaling_mock_test.go new file mode 100644 index 00000000..98b308d3 --- /dev/null +++ b/resources/autoscaling_mock_test.go @@ -0,0 +1,4 @@ +//go:generate ../mocks/generate_mocks.sh autoscaling autoscalingiface +package resources + +// Note: empty on purpose, this file exist purely to generate mocks for the AutoScaling service