4225 lines
127 KiB
Go
4225 lines
127 KiB
Go
// Code generated by mockery v0.0.0-dev. DO NOT EDIT.
|
|
|
|
package repository
|
|
|
|
import (
|
|
context "context"
|
|
|
|
lambda "github.com/aws/aws-sdk-go/service/lambda"
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
request "github.com/aws/aws-sdk-go/aws/request"
|
|
)
|
|
|
|
// MockLambdaClient is an autogenerated mock type for the LambdaClient type
|
|
type MockLambdaClient struct {
|
|
mock.Mock
|
|
}
|
|
|
|
// AddLayerVersionPermission provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) AddLayerVersionPermission(_a0 *lambda.AddLayerVersionPermissionInput) (*lambda.AddLayerVersionPermissionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.AddLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.AddLayerVersionPermissionInput) *lambda.AddLayerVersionPermissionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AddLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.AddLayerVersionPermissionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddLayerVersionPermissionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) AddLayerVersionPermissionRequest(_a0 *lambda.AddLayerVersionPermissionInput) (*request.Request, *lambda.AddLayerVersionPermissionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.AddLayerVersionPermissionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.AddLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.AddLayerVersionPermissionInput) *lambda.AddLayerVersionPermissionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.AddLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) AddLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.AddLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.AddLayerVersionPermissionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.AddLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.AddLayerVersionPermissionInput, ...request.Option) *lambda.AddLayerVersionPermissionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AddLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.AddLayerVersionPermissionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddPermission provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) AddPermission(_a0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.AddPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.AddPermissionInput) *lambda.AddPermissionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AddPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.AddPermissionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddPermissionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) AddPermissionRequest(_a0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.AddPermissionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.AddPermissionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.AddPermissionInput) *lambda.AddPermissionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.AddPermissionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// AddPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) AddPermissionWithContext(_a0 context.Context, _a1 *lambda.AddPermissionInput, _a2 ...request.Option) (*lambda.AddPermissionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.AddPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.AddPermissionInput, ...request.Option) *lambda.AddPermissionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AddPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.AddPermissionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateAlias provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateAlias(_a0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateAliasInput) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateAliasInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateAliasRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateAliasRequest(_a0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateAliasInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateAliasInput) *lambda.AliasConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) CreateAliasWithContext(_a0 context.Context, _a1 *lambda.CreateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateAliasInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEventSourceMapping provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateEventSourceMapping(_a0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateEventSourceMappingInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEventSourceMappingRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateEventSourceMappingRequest(_a0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateEventSourceMappingInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) CreateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.CreateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateEventSourceMappingInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateFunction provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateFunction(_a0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateFunctionInput) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateFunctionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateFunctionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) CreateFunctionRequest(_a0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.CreateFunctionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.CreateFunctionInput) *lambda.FunctionConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// CreateFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) CreateFunctionWithContext(_a0 context.Context, _a1 *lambda.CreateFunctionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.CreateFunctionInput, ...request.Option) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.CreateFunctionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteAlias provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteAlias(_a0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteAliasOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteAliasInput) *lambda.DeleteAliasOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteAliasOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteAliasInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteAliasRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteAliasRequest(_a0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteAliasInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteAliasOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteAliasInput) *lambda.DeleteAliasOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteAliasOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteAliasWithContext(_a0 context.Context, _a1 *lambda.DeleteAliasInput, _a2 ...request.Option) (*lambda.DeleteAliasOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteAliasOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteAliasInput, ...request.Option) *lambda.DeleteAliasOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteAliasOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteAliasInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteEventSourceMapping provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteEventSourceMapping(_a0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteEventSourceMappingInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteEventSourceMappingRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteEventSourceMappingRequest(_a0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteEventSourceMappingInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.DeleteEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteEventSourceMappingInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunction provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunction(_a0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionInput) *lambda.DeleteFunctionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionConcurrency provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunctionConcurrency(_a0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionConcurrencyInput) *lambda.DeleteFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionConcurrencyInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionConcurrencyRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunctionConcurrencyRequest(_a0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionConcurrencyInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionConcurrencyInput) *lambda.DeleteFunctionConcurrencyOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionConcurrencyInput, ...request.Option) *lambda.DeleteFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionConcurrencyInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionEventInvokeConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunctionEventInvokeConfig(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionEventInvokeConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunctionEventInvokeConfigRequest(_a0 *lambda.DeleteFunctionEventInvokeConfigInput) (*request.Request, *lambda.DeleteFunctionEventInvokeConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionEventInvokeConfigInput) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.DeleteFunctionEventInvokeConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionEventInvokeConfigInput, ...request.Option) *lambda.DeleteFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionEventInvokeConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteFunctionRequest(_a0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteFunctionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteFunctionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteFunctionInput) *lambda.DeleteFunctionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteFunctionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteFunctionWithContext(_a0 context.Context, _a1 *lambda.DeleteFunctionInput, _a2 ...request.Option) (*lambda.DeleteFunctionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteFunctionInput, ...request.Option) *lambda.DeleteFunctionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteFunctionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteLayerVersion provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteLayerVersion(_a0 *lambda.DeleteLayerVersionInput) (*lambda.DeleteLayerVersionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteLayerVersionInput) *lambda.DeleteLayerVersionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteLayerVersionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteLayerVersionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteLayerVersionRequest(_a0 *lambda.DeleteLayerVersionInput) (*request.Request, *lambda.DeleteLayerVersionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteLayerVersionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteLayerVersionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteLayerVersionInput) *lambda.DeleteLayerVersionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteLayerVersionWithContext(_a0 context.Context, _a1 *lambda.DeleteLayerVersionInput, _a2 ...request.Option) (*lambda.DeleteLayerVersionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteLayerVersionInput, ...request.Option) *lambda.DeleteLayerVersionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteLayerVersionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteProvisionedConcurrencyConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteProvisionedConcurrencyConfig(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.DeleteProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) DeleteProvisionedConcurrencyConfigRequest(_a0 *lambda.DeleteProvisionedConcurrencyConfigInput) (*request.Request, *lambda.DeleteProvisionedConcurrencyConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.DeleteProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.DeleteProvisionedConcurrencyConfigInput) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// DeleteProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) DeleteProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.DeleteProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.DeleteProvisionedConcurrencyConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.DeleteProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.DeleteProvisionedConcurrencyConfigInput, ...request.Option) *lambda.DeleteProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.DeleteProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.DeleteProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAccountSettings provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetAccountSettings(_a0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetAccountSettingsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetAccountSettingsInput) *lambda.GetAccountSettingsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetAccountSettingsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetAccountSettingsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAccountSettingsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetAccountSettingsRequest(_a0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetAccountSettingsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetAccountSettingsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetAccountSettingsInput) *lambda.GetAccountSettingsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetAccountSettingsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAccountSettingsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetAccountSettingsWithContext(_a0 context.Context, _a1 *lambda.GetAccountSettingsInput, _a2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetAccountSettingsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetAccountSettingsInput, ...request.Option) *lambda.GetAccountSettingsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetAccountSettingsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetAccountSettingsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAlias provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetAlias(_a0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetAliasInput) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetAliasInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAliasRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetAliasRequest(_a0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetAliasInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetAliasInput) *lambda.AliasConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetAliasWithContext(_a0 context.Context, _a1 *lambda.GetAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetAliasInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEventSourceMapping provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetEventSourceMapping(_a0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetEventSourceMappingInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEventSourceMappingRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetEventSourceMappingRequest(_a0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetEventSourceMappingInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.GetEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetEventSourceMappingInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunction provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunction(_a0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) *lambda.GetFunctionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConcurrency provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionConcurrency(_a0 *lambda.GetFunctionConcurrencyInput) (*lambda.GetFunctionConcurrencyOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConcurrencyInput) *lambda.GetFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConcurrencyInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConcurrencyRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionConcurrencyRequest(_a0 *lambda.GetFunctionConcurrencyInput) (*request.Request, *lambda.GetFunctionConcurrencyOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConcurrencyInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConcurrencyInput) *lambda.GetFunctionConcurrencyOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.GetFunctionConcurrencyOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConcurrencyInput, ...request.Option) *lambda.GetFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionConcurrencyInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConfiguration provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionConfiguration(_a0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConfigurationInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConfigurationRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionConfigurationRequest(_a0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.Option) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionEventInvokeConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionEventInvokeConfig(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionEventInvokeConfigInput) *lambda.GetFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionEventInvokeConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionEventInvokeConfigRequest(_a0 *lambda.GetFunctionEventInvokeConfigInput) (*request.Request, *lambda.GetFunctionEventInvokeConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionEventInvokeConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionEventInvokeConfigInput) *lambda.GetFunctionEventInvokeConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.GetFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.GetFunctionEventInvokeConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionEventInvokeConfigInput, ...request.Option) *lambda.GetFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionEventInvokeConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetFunctionRequest(_a0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetFunctionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetFunctionInput) *lambda.GetFunctionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetFunctionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetFunctionWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.Option) (*lambda.GetFunctionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionInput, ...request.Option) *lambda.GetFunctionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetFunctionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersion provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersion(_a0 *lambda.GetLayerVersionInput) (*lambda.GetLayerVersionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionInput) *lambda.GetLayerVersionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionByArn provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersionByArn(_a0 *lambda.GetLayerVersionByArnInput) (*lambda.GetLayerVersionByArnOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetLayerVersionByArnOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionByArnInput) *lambda.GetLayerVersionByArnOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionByArnOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionByArnInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionByArnRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersionByArnRequest(_a0 *lambda.GetLayerVersionByArnInput) (*request.Request, *lambda.GetLayerVersionByArnOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionByArnInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetLayerVersionByArnOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionByArnInput) *lambda.GetLayerVersionByArnOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetLayerVersionByArnOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionByArnWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetLayerVersionByArnWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionByArnInput, _a2 ...request.Option) (*lambda.GetLayerVersionByArnOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetLayerVersionByArnOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionByArnInput, ...request.Option) *lambda.GetLayerVersionByArnOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionByArnOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionByArnInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionPolicy provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersionPolicy(_a0 *lambda.GetLayerVersionPolicyInput) (*lambda.GetLayerVersionPolicyOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetLayerVersionPolicyOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionPolicyInput) *lambda.GetLayerVersionPolicyOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionPolicyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionPolicyInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionPolicyRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersionPolicyRequest(_a0 *lambda.GetLayerVersionPolicyInput) (*request.Request, *lambda.GetLayerVersionPolicyOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionPolicyInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetLayerVersionPolicyOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionPolicyInput) *lambda.GetLayerVersionPolicyOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetLayerVersionPolicyOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetLayerVersionPolicyWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionPolicyInput, _a2 ...request.Option) (*lambda.GetLayerVersionPolicyOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetLayerVersionPolicyOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionPolicyInput, ...request.Option) *lambda.GetLayerVersionPolicyOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionPolicyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionPolicyInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetLayerVersionRequest(_a0 *lambda.GetLayerVersionInput) (*request.Request, *lambda.GetLayerVersionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetLayerVersionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetLayerVersionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetLayerVersionInput) *lambda.GetLayerVersionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetLayerVersionWithContext(_a0 context.Context, _a1 *lambda.GetLayerVersionInput, _a2 ...request.Option) (*lambda.GetLayerVersionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetLayerVersionInput, ...request.Option) *lambda.GetLayerVersionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetLayerVersionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPolicy provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetPolicy(_a0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetPolicyOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetPolicyInput) *lambda.GetPolicyOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetPolicyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetPolicyInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPolicyRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetPolicyRequest(_a0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetPolicyInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetPolicyOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetPolicyInput) *lambda.GetPolicyOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetPolicyOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetPolicyWithContext(_a0 context.Context, _a1 *lambda.GetPolicyInput, _a2 ...request.Option) (*lambda.GetPolicyOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetPolicyOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetPolicyInput, ...request.Option) *lambda.GetPolicyOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetPolicyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetPolicyInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetProvisionedConcurrencyConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetProvisionedConcurrencyConfig(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.GetProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetProvisionedConcurrencyConfigInput) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetProvisionedConcurrencyConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) GetProvisionedConcurrencyConfigRequest(_a0 *lambda.GetProvisionedConcurrencyConfigInput) (*request.Request, *lambda.GetProvisionedConcurrencyConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetProvisionedConcurrencyConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.GetProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.GetProvisionedConcurrencyConfigInput) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.GetProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// GetProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) GetProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.GetProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.GetProvisionedConcurrencyConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.GetProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetProvisionedConcurrencyConfigInput, ...request.Option) *lambda.GetProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.GetProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.GetProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Invoke provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) Invoke(_a0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.InvokeOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.InvokeInput) *lambda.InvokeOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.InvokeOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.InvokeInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// InvokeAsync provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) InvokeAsync(_a0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.InvokeAsyncOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.InvokeAsyncInput) *lambda.InvokeAsyncOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.InvokeAsyncOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.InvokeAsyncInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// InvokeAsyncRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) InvokeAsyncRequest(_a0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.InvokeAsyncInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.InvokeAsyncOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.InvokeAsyncInput) *lambda.InvokeAsyncOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.InvokeAsyncOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// InvokeAsyncWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) InvokeAsyncWithContext(_a0 context.Context, _a1 *lambda.InvokeAsyncInput, _a2 ...request.Option) (*lambda.InvokeAsyncOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.InvokeAsyncOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.InvokeAsyncInput, ...request.Option) *lambda.InvokeAsyncOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.InvokeAsyncOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.InvokeAsyncInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// InvokeRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) InvokeRequest(_a0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.InvokeInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.InvokeOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.InvokeInput) *lambda.InvokeOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.InvokeOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// InvokeWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) InvokeWithContext(_a0 context.Context, _a1 *lambda.InvokeInput, _a2 ...request.Option) (*lambda.InvokeOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.InvokeOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.InvokeInput, ...request.Option) *lambda.InvokeOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.InvokeOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.InvokeInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAliases provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListAliases(_a0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListAliasesOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput) *lambda.ListAliasesOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListAliasesOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListAliasesInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAliasesPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListAliasesPages(_a0 *lambda.ListAliasesInput, _a1 func(*lambda.ListAliasesOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListAliasesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListAliasesPagesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 func(*lambda.ListAliasesOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListAliasesInput, func(*lambda.ListAliasesOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListAliasesRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListAliasesRequest(_a0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListAliasesInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListAliasesOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListAliasesInput) *lambda.ListAliasesOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListAliasesOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListAliasesWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListAliasesWithContext(_a0 context.Context, _a1 *lambda.ListAliasesInput, _a2 ...request.Option) (*lambda.ListAliasesOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListAliasesOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListAliasesInput, ...request.Option) *lambda.ListAliasesOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListAliasesOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListAliasesInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEventSourceMappings provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListEventSourceMappings(_a0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListEventSourceMappingsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput) *lambda.ListEventSourceMappingsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListEventSourceMappingsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListEventSourceMappingsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEventSourceMappingsPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListEventSourceMappingsPages(_a0 *lambda.ListEventSourceMappingsInput, _a1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListEventSourceMappingsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListEventSourceMappingsPagesWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 func(*lambda.ListEventSourceMappingsOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListEventSourceMappingsInput, func(*lambda.ListEventSourceMappingsOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListEventSourceMappingsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListEventSourceMappingsRequest(_a0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListEventSourceMappingsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListEventSourceMappingsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListEventSourceMappingsInput) *lambda.ListEventSourceMappingsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListEventSourceMappingsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListEventSourceMappingsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListEventSourceMappingsWithContext(_a0 context.Context, _a1 *lambda.ListEventSourceMappingsInput, _a2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListEventSourceMappingsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListEventSourceMappingsInput, ...request.Option) *lambda.ListEventSourceMappingsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListEventSourceMappingsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListEventSourceMappingsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctionEventInvokeConfigs provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListFunctionEventInvokeConfigs(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListFunctionEventInvokeConfigsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListFunctionEventInvokeConfigsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListFunctionEventInvokeConfigsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctionEventInvokeConfigsPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListFunctionEventInvokeConfigsPages(_a0 *lambda.ListFunctionEventInvokeConfigsInput, _a1 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListFunctionEventInvokeConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListFunctionEventInvokeConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, func(*lambda.ListFunctionEventInvokeConfigsOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListFunctionEventInvokeConfigsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListFunctionEventInvokeConfigsRequest(_a0 *lambda.ListFunctionEventInvokeConfigsInput) (*request.Request, *lambda.ListFunctionEventInvokeConfigsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionEventInvokeConfigsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListFunctionEventInvokeConfigsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListFunctionEventInvokeConfigsInput) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListFunctionEventInvokeConfigsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctionEventInvokeConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListFunctionEventInvokeConfigsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionEventInvokeConfigsInput, _a2 ...request.Option) (*lambda.ListFunctionEventInvokeConfigsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListFunctionEventInvokeConfigsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, ...request.Option) *lambda.ListFunctionEventInvokeConfigsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListFunctionEventInvokeConfigsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListFunctionEventInvokeConfigsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctions provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListFunctions(_a0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListFunctionsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput) *lambda.ListFunctionsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListFunctionsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctionsPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListFunctionsPages(_a0 *lambda.ListFunctionsInput, _a1 func(*lambda.ListFunctionsOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListFunctionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListFunctionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 func(*lambda.ListFunctionsOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsInput, func(*lambda.ListFunctionsOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListFunctionsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListFunctionsRequest(_a0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListFunctionsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListFunctionsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListFunctionsInput) *lambda.ListFunctionsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListFunctionsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListFunctionsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListFunctionsWithContext(_a0 context.Context, _a1 *lambda.ListFunctionsInput, _a2 ...request.Option) (*lambda.ListFunctionsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListFunctionsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListFunctionsInput, ...request.Option) *lambda.ListFunctionsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListFunctionsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListFunctionsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayerVersions provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListLayerVersions(_a0 *lambda.ListLayerVersionsInput) (*lambda.ListLayerVersionsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListLayerVersionsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput) *lambda.ListLayerVersionsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListLayerVersionsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListLayerVersionsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayerVersionsPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListLayerVersionsPages(_a0 *lambda.ListLayerVersionsInput, _a1 func(*lambda.ListLayerVersionsOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListLayerVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListLayerVersionsPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 func(*lambda.ListLayerVersionsOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayerVersionsInput, func(*lambda.ListLayerVersionsOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListLayerVersionsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListLayerVersionsRequest(_a0 *lambda.ListLayerVersionsInput) (*request.Request, *lambda.ListLayerVersionsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayerVersionsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListLayerVersionsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListLayerVersionsInput) *lambda.ListLayerVersionsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListLayerVersionsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayerVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListLayerVersionsWithContext(_a0 context.Context, _a1 *lambda.ListLayerVersionsInput, _a2 ...request.Option) (*lambda.ListLayerVersionsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListLayerVersionsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayerVersionsInput, ...request.Option) *lambda.ListLayerVersionsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListLayerVersionsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListLayerVersionsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayers provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListLayers(_a0 *lambda.ListLayersInput) (*lambda.ListLayersOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListLayersOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput) *lambda.ListLayersOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListLayersOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListLayersInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayersPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListLayersPages(_a0 *lambda.ListLayersInput, _a1 func(*lambda.ListLayersOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListLayersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListLayersPagesWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 func(*lambda.ListLayersOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayersInput, func(*lambda.ListLayersOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListLayersRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListLayersRequest(_a0 *lambda.ListLayersInput) (*request.Request, *lambda.ListLayersOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListLayersInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListLayersOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListLayersInput) *lambda.ListLayersOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListLayersOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListLayersWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListLayersWithContext(_a0 context.Context, _a1 *lambda.ListLayersInput, _a2 ...request.Option) (*lambda.ListLayersOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListLayersOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListLayersInput, ...request.Option) *lambda.ListLayersOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListLayersOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListLayersInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListProvisionedConcurrencyConfigs provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListProvisionedConcurrencyConfigs(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListProvisionedConcurrencyConfigsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListProvisionedConcurrencyConfigsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListProvisionedConcurrencyConfigsPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListProvisionedConcurrencyConfigsPages(_a0 *lambda.ListProvisionedConcurrencyConfigsInput, _a1 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListProvisionedConcurrencyConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListProvisionedConcurrencyConfigsPagesWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, func(*lambda.ListProvisionedConcurrencyConfigsOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListProvisionedConcurrencyConfigsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListProvisionedConcurrencyConfigsRequest(_a0 *lambda.ListProvisionedConcurrencyConfigsInput) (*request.Request, *lambda.ListProvisionedConcurrencyConfigsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListProvisionedConcurrencyConfigsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListProvisionedConcurrencyConfigsInput) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListProvisionedConcurrencyConfigsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListProvisionedConcurrencyConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListProvisionedConcurrencyConfigsWithContext(_a0 context.Context, _a1 *lambda.ListProvisionedConcurrencyConfigsInput, _a2 ...request.Option) (*lambda.ListProvisionedConcurrencyConfigsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListProvisionedConcurrencyConfigsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, ...request.Option) *lambda.ListProvisionedConcurrencyConfigsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListProvisionedConcurrencyConfigsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListProvisionedConcurrencyConfigsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListTags provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListTags(_a0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListTagsOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListTagsInput) *lambda.ListTagsOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListTagsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListTagsInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListTagsRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListTagsRequest(_a0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListTagsInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListTagsOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListTagsInput) *lambda.ListTagsOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListTagsOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListTagsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListTagsWithContext(_a0 context.Context, _a1 *lambda.ListTagsInput, _a2 ...request.Option) (*lambda.ListTagsOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListTagsOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListTagsInput, ...request.Option) *lambda.ListTagsOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListTagsOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListTagsInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListVersionsByFunction provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListVersionsByFunction(_a0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.ListVersionsByFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput) *lambda.ListVersionsByFunctionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListVersionsByFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListVersionsByFunctionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListVersionsByFunctionPages provides a mock function with given fields: _a0, _a1
|
|
func (_m *MockLambdaClient) ListVersionsByFunctionPages(_a0 *lambda.ListVersionsByFunctionInput, _a1 func(*lambda.ListVersionsByFunctionOutput, bool) bool) error {
|
|
ret := _m.Called(_a0, _a1)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool) error); ok {
|
|
r0 = rf(_a0, _a1)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListVersionsByFunctionPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
|
|
func (_m *MockLambdaClient) ListVersionsByFunctionPagesWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 func(*lambda.ListVersionsByFunctionOutput, bool) bool, _a3 ...request.Option) error {
|
|
_va := make([]interface{}, len(_a3))
|
|
for _i := range _a3 {
|
|
_va[_i] = _a3[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1, _a2)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListVersionsByFunctionInput, func(*lambda.ListVersionsByFunctionOutput, bool) bool, ...request.Option) error); ok {
|
|
r0 = rf(_a0, _a1, _a2, _a3...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// ListVersionsByFunctionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) ListVersionsByFunctionRequest(_a0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.ListVersionsByFunctionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.ListVersionsByFunctionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.ListVersionsByFunctionInput) *lambda.ListVersionsByFunctionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.ListVersionsByFunctionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// ListVersionsByFunctionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) ListVersionsByFunctionWithContext(_a0 context.Context, _a1 *lambda.ListVersionsByFunctionInput, _a2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.ListVersionsByFunctionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.ListVersionsByFunctionInput, ...request.Option) *lambda.ListVersionsByFunctionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.ListVersionsByFunctionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.ListVersionsByFunctionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishLayerVersion provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PublishLayerVersion(_a0 *lambda.PublishLayerVersionInput) (*lambda.PublishLayerVersionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.PublishLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.PublishLayerVersionInput) *lambda.PublishLayerVersionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PublishLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.PublishLayerVersionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishLayerVersionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PublishLayerVersionRequest(_a0 *lambda.PublishLayerVersionInput) (*request.Request, *lambda.PublishLayerVersionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.PublishLayerVersionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.PublishLayerVersionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.PublishLayerVersionInput) *lambda.PublishLayerVersionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.PublishLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishLayerVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) PublishLayerVersionWithContext(_a0 context.Context, _a1 *lambda.PublishLayerVersionInput, _a2 ...request.Option) (*lambda.PublishLayerVersionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.PublishLayerVersionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.PublishLayerVersionInput, ...request.Option) *lambda.PublishLayerVersionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PublishLayerVersionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.PublishLayerVersionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishVersion provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PublishVersion(_a0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.PublishVersionInput) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.PublishVersionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishVersionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PublishVersionRequest(_a0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.PublishVersionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.PublishVersionInput) *lambda.FunctionConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PublishVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) PublishVersionWithContext(_a0 context.Context, _a1 *lambda.PublishVersionInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.PublishVersionInput, ...request.Option) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.PublishVersionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionConcurrency provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutFunctionConcurrency(_a0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.PutFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutFunctionConcurrencyInput) *lambda.PutFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutFunctionConcurrencyInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionConcurrencyRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutFunctionConcurrencyRequest(_a0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutFunctionConcurrencyInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.PutFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutFunctionConcurrencyInput) *lambda.PutFunctionConcurrencyOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.PutFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionConcurrencyWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) PutFunctionConcurrencyWithContext(_a0 context.Context, _a1 *lambda.PutFunctionConcurrencyInput, _a2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.PutFunctionConcurrencyOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutFunctionConcurrencyInput, ...request.Option) *lambda.PutFunctionConcurrencyOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutFunctionConcurrencyOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutFunctionConcurrencyInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionEventInvokeConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutFunctionEventInvokeConfig(_a0 *lambda.PutFunctionEventInvokeConfigInput) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.PutFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutFunctionEventInvokeConfigInput) *lambda.PutFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutFunctionEventInvokeConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutFunctionEventInvokeConfigRequest(_a0 *lambda.PutFunctionEventInvokeConfigInput) (*request.Request, *lambda.PutFunctionEventInvokeConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutFunctionEventInvokeConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.PutFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutFunctionEventInvokeConfigInput) *lambda.PutFunctionEventInvokeConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.PutFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) PutFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.PutFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.PutFunctionEventInvokeConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.PutFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutFunctionEventInvokeConfigInput, ...request.Option) *lambda.PutFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutFunctionEventInvokeConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutProvisionedConcurrencyConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutProvisionedConcurrencyConfig(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.PutProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutProvisionedConcurrencyConfigInput) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutProvisionedConcurrencyConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutProvisionedConcurrencyConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) PutProvisionedConcurrencyConfigRequest(_a0 *lambda.PutProvisionedConcurrencyConfigInput) (*request.Request, *lambda.PutProvisionedConcurrencyConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.PutProvisionedConcurrencyConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.PutProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.PutProvisionedConcurrencyConfigInput) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.PutProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// PutProvisionedConcurrencyConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) PutProvisionedConcurrencyConfigWithContext(_a0 context.Context, _a1 *lambda.PutProvisionedConcurrencyConfigInput, _a2 ...request.Option) (*lambda.PutProvisionedConcurrencyConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.PutProvisionedConcurrencyConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.PutProvisionedConcurrencyConfigInput, ...request.Option) *lambda.PutProvisionedConcurrencyConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.PutProvisionedConcurrencyConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.PutProvisionedConcurrencyConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemoveLayerVersionPermission provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) RemoveLayerVersionPermission(_a0 *lambda.RemoveLayerVersionPermissionInput) (*lambda.RemoveLayerVersionPermissionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.RemoveLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.RemoveLayerVersionPermissionInput) *lambda.RemoveLayerVersionPermissionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.RemoveLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.RemoveLayerVersionPermissionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemoveLayerVersionPermissionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) RemoveLayerVersionPermissionRequest(_a0 *lambda.RemoveLayerVersionPermissionInput) (*request.Request, *lambda.RemoveLayerVersionPermissionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.RemoveLayerVersionPermissionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.RemoveLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.RemoveLayerVersionPermissionInput) *lambda.RemoveLayerVersionPermissionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.RemoveLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemoveLayerVersionPermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) RemoveLayerVersionPermissionWithContext(_a0 context.Context, _a1 *lambda.RemoveLayerVersionPermissionInput, _a2 ...request.Option) (*lambda.RemoveLayerVersionPermissionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.RemoveLayerVersionPermissionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.RemoveLayerVersionPermissionInput, ...request.Option) *lambda.RemoveLayerVersionPermissionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.RemoveLayerVersionPermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.RemoveLayerVersionPermissionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemovePermission provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) RemovePermission(_a0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.RemovePermissionOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.RemovePermissionInput) *lambda.RemovePermissionOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.RemovePermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.RemovePermissionInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemovePermissionRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) RemovePermissionRequest(_a0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.RemovePermissionInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.RemovePermissionOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.RemovePermissionInput) *lambda.RemovePermissionOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.RemovePermissionOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// RemovePermissionWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) RemovePermissionWithContext(_a0 context.Context, _a1 *lambda.RemovePermissionInput, _a2 ...request.Option) (*lambda.RemovePermissionOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.RemovePermissionOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.RemovePermissionInput, ...request.Option) *lambda.RemovePermissionOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.RemovePermissionOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.RemovePermissionInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// TagResource provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) TagResource(_a0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.TagResourceOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.TagResourceInput) *lambda.TagResourceOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.TagResourceOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.TagResourceInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// TagResourceRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) TagResourceRequest(_a0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.TagResourceInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.TagResourceOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.TagResourceInput) *lambda.TagResourceOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.TagResourceOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) TagResourceWithContext(_a0 context.Context, _a1 *lambda.TagResourceInput, _a2 ...request.Option) (*lambda.TagResourceOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.TagResourceOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.TagResourceInput, ...request.Option) *lambda.TagResourceOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.TagResourceOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.TagResourceInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UntagResource provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UntagResource(_a0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.UntagResourceOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.UntagResourceInput) *lambda.UntagResourceOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.UntagResourceOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UntagResourceInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UntagResourceRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UntagResourceRequest(_a0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UntagResourceInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.UntagResourceOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.UntagResourceInput) *lambda.UntagResourceOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.UntagResourceOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UntagResourceWithContext(_a0 context.Context, _a1 *lambda.UntagResourceInput, _a2 ...request.Option) (*lambda.UntagResourceOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.UntagResourceOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UntagResourceInput, ...request.Option) *lambda.UntagResourceOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.UntagResourceOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UntagResourceInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateAlias provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateAlias(_a0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateAliasInput) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateAliasInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateAliasRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateAliasRequest(_a0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateAliasInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateAliasInput) *lambda.AliasConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateAliasWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UpdateAliasWithContext(_a0 context.Context, _a1 *lambda.UpdateAliasInput, _a2 ...request.Option) (*lambda.AliasConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.AliasConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateAliasInput, ...request.Option) *lambda.AliasConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.AliasConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateAliasInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEventSourceMapping provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateEventSourceMapping(_a0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateEventSourceMappingInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEventSourceMappingRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateEventSourceMappingRequest(_a0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateEventSourceMappingInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateEventSourceMappingInput) *lambda.EventSourceMappingConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateEventSourceMappingWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UpdateEventSourceMappingWithContext(_a0 context.Context, _a1 *lambda.UpdateEventSourceMappingInput, _a2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.EventSourceMappingConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateEventSourceMappingInput, ...request.Option) *lambda.EventSourceMappingConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.EventSourceMappingConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateEventSourceMappingInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionCode provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionCode(_a0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionCodeInput) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionCodeInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionCodeRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionCodeRequest(_a0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionCodeInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionCodeInput) *lambda.FunctionConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionCodeWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UpdateFunctionCodeWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionCodeInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionCodeInput, ...request.Option) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionCodeInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionConfiguration provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionConfiguration(_a0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionConfigurationInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionConfigurationRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionConfigurationRequest(_a0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionConfigurationInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionConfigurationInput) *lambda.FunctionConfiguration); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UpdateFunctionConfigurationWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionConfigurationInput, _a2 ...request.Option) (*lambda.FunctionConfiguration, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.FunctionConfiguration
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionConfigurationInput, ...request.Option) *lambda.FunctionConfiguration); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.FunctionConfiguration)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionConfigurationInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionEventInvokeConfig provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionEventInvokeConfig(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *lambda.UpdateFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.UpdateFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionEventInvokeConfigInput) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionEventInvokeConfigRequest provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) UpdateFunctionEventInvokeConfigRequest(_a0 *lambda.UpdateFunctionEventInvokeConfigInput) (*request.Request, *lambda.UpdateFunctionEventInvokeConfigOutput) {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 *request.Request
|
|
if rf, ok := ret.Get(0).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *request.Request); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*request.Request)
|
|
}
|
|
}
|
|
|
|
var r1 *lambda.UpdateFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(1).(func(*lambda.UpdateFunctionEventInvokeConfigInput) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
if ret.Get(1) != nil {
|
|
r1 = ret.Get(1).(*lambda.UpdateFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// UpdateFunctionEventInvokeConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) UpdateFunctionEventInvokeConfigWithContext(_a0 context.Context, _a1 *lambda.UpdateFunctionEventInvokeConfigInput, _a2 ...request.Option) (*lambda.UpdateFunctionEventInvokeConfigOutput, error) {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 *lambda.UpdateFunctionEventInvokeConfigOutput
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.UpdateFunctionEventInvokeConfigInput, ...request.Option) *lambda.UpdateFunctionEventInvokeConfigOutput); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*lambda.UpdateFunctionEventInvokeConfigOutput)
|
|
}
|
|
}
|
|
|
|
var r1 error
|
|
if rf, ok := ret.Get(1).(func(context.Context, *lambda.UpdateFunctionEventInvokeConfigInput, ...request.Option) error); ok {
|
|
r1 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// WaitUntilFunctionActive provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) WaitUntilFunctionActive(_a0 *lambda.GetFunctionConfigurationInput) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitUntilFunctionActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) WaitUntilFunctionActiveWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitUntilFunctionExists provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) WaitUntilFunctionExists(_a0 *lambda.GetFunctionInput) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionInput) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitUntilFunctionExistsWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) WaitUntilFunctionExistsWithContext(_a0 context.Context, _a1 *lambda.GetFunctionInput, _a2 ...request.WaiterOption) error {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionInput, ...request.WaiterOption) error); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitUntilFunctionUpdated provides a mock function with given fields: _a0
|
|
func (_m *MockLambdaClient) WaitUntilFunctionUpdated(_a0 *lambda.GetFunctionConfigurationInput) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*lambda.GetFunctionConfigurationInput) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// WaitUntilFunctionUpdatedWithContext provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *MockLambdaClient) WaitUntilFunctionUpdatedWithContext(_a0 context.Context, _a1 *lambda.GetFunctionConfigurationInput, _a2 ...request.WaiterOption) error {
|
|
_va := make([]interface{}, len(_a2))
|
|
for _i := range _a2 {
|
|
_va[_i] = _a2[_i]
|
|
}
|
|
var _ca []interface{}
|
|
_ca = append(_ca, _a0, _a1)
|
|
_ca = append(_ca, _va...)
|
|
ret := _m.Called(_ca...)
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, *lambda.GetFunctionConfigurationInput, ...request.WaiterOption) error); ok {
|
|
r0 = rf(_a0, _a1, _a2...)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|