repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
apex/apex | mock/lambdaiface.go | AddPermissionRequest | func (m *MockLambdaAPI) AddPermissionRequest(arg0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AddPermissionOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) AddPermissionRequest(arg0 *lambda.AddPermissionInput) (*request.Request, *lambda.AddPermissionOutput) {
ret := m.ctrl.Call(m, "AddPermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AddPermissionOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"AddPermissionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"AddPermissionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"AddPermissionOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // AddPermissionRequest mocks base method | [
"AddPermissionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L52-L57 | train |
apex/apex | mock/lambdaiface.go | AddPermissionWithContext | func (m *MockLambdaAPI) AddPermissionWithContext(arg0 aws.Context, arg1 *lambda.AddPermissionInput, arg2 ...request.Option) (*lambda.AddPermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) AddPermissionWithContext(arg0 aws.Context, arg1 *lambda.AddPermissionInput, arg2 ...request.Option) (*lambda.AddPermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "AddPermissionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"AddPermissionWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"AddPermissionInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // AddPermissionWithContext mocks base method | [
"AddPermissionWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L65-L74 | train |
apex/apex | mock/lambdaiface.go | CreateAlias | func (m *MockLambdaAPI) CreateAlias(arg0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "CreateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateAlias(arg0 *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "CreateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateAlias",
"(",
"arg0",
"*",
"lambda",
".",
"CreateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateAlias mocks base method | [
"CreateAlias",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L83-L88 | train |
apex/apex | mock/lambdaiface.go | CreateAliasRequest | func (m *MockLambdaAPI) CreateAliasRequest(arg0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateAliasRequest(arg0 *lambda.CreateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "CreateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateAliasRequest",
"(",
"arg0",
"*",
"lambda",
".",
"CreateAliasInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateAliasRequest mocks base method | [
"CreateAliasRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L96-L101 | train |
apex/apex | mock/lambdaiface.go | CreateAliasWithContext | func (m *MockLambdaAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *lambda.CreateAliasInput, arg2 ...request.Option) (*lambda.AliasConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateAliasWithContext(arg0 aws.Context, arg1 *lambda.CreateAliasInput, arg2 ...request.Option) (*lambda.AliasConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "CreateAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateAliasWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"CreateAliasInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateAliasWithContext mocks base method | [
"CreateAliasWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L109-L118 | train |
apex/apex | mock/lambdaiface.go | CreateEventSourceMapping | func (m *MockLambdaAPI) CreateEventSourceMapping(arg0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "CreateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateEventSourceMapping(arg0 *lambda.CreateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "CreateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateEventSourceMapping",
"(",
"arg0",
"*",
"lambda",
".",
"CreateEventSourceMappingInput",
")",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateEventSourceMapping mocks base method | [
"CreateEventSourceMapping",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L127-L132 | train |
apex/apex | mock/lambdaiface.go | CreateEventSourceMappingRequest | func (m *MockLambdaAPI) CreateEventSourceMappingRequest(arg0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "CreateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateEventSourceMappingRequest(arg0 *lambda.CreateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "CreateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateEventSourceMappingRequest",
"(",
"arg0",
"*",
"lambda",
".",
"CreateEventSourceMappingInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateEventSourceMappingRequest mocks base method | [
"CreateEventSourceMappingRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L140-L145 | train |
apex/apex | mock/lambdaiface.go | CreateFunction | func (m *MockLambdaAPI) CreateFunction(arg0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "CreateFunction", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateFunction(arg0 *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "CreateFunction", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateFunction",
"(",
"arg0",
"*",
"lambda",
".",
"CreateFunctionInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateFunction mocks base method | [
"CreateFunction",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L171-L176 | train |
apex/apex | mock/lambdaiface.go | CreateFunctionRequest | func (m *MockLambdaAPI) CreateFunctionRequest(arg0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "CreateFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) CreateFunctionRequest(arg0 *lambda.CreateFunctionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "CreateFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"CreateFunctionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"CreateFunctionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // CreateFunctionRequest mocks base method | [
"CreateFunctionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L184-L189 | train |
apex/apex | mock/lambdaiface.go | DeleteAlias | func (m *MockLambdaAPI) DeleteAlias(arg0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
ret := m.ctrl.Call(m, "DeleteAlias", arg0)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteAlias(arg0 *lambda.DeleteAliasInput) (*lambda.DeleteAliasOutput, error) {
ret := m.ctrl.Call(m, "DeleteAlias", arg0)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteAlias",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteAliasInput",
")",
"(",
"*",
"lambda",
".",
"DeleteAliasOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteAliasOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteAlias mocks base method | [
"DeleteAlias",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L215-L220 | train |
apex/apex | mock/lambdaiface.go | DeleteAliasRequest | func (m *MockLambdaAPI) DeleteAliasRequest(arg0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteAliasOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteAliasRequest(arg0 *lambda.DeleteAliasInput) (*request.Request, *lambda.DeleteAliasOutput) {
ret := m.ctrl.Call(m, "DeleteAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteAliasOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteAliasRequest",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteAliasInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"DeleteAliasOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteAliasOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteAliasRequest mocks base method | [
"DeleteAliasRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L228-L233 | train |
apex/apex | mock/lambdaiface.go | DeleteAliasWithContext | func (m *MockLambdaAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *lambda.DeleteAliasInput, arg2 ...request.Option) (*lambda.DeleteAliasOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteAliasWithContext(arg0 aws.Context, arg1 *lambda.DeleteAliasInput, arg2 ...request.Option) (*lambda.DeleteAliasOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteAliasWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteAliasOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteAliasWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"DeleteAliasInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"DeleteAliasOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteAliasOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteAliasWithContext mocks base method | [
"DeleteAliasWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L241-L250 | train |
apex/apex | mock/lambdaiface.go | DeleteEventSourceMapping | func (m *MockLambdaAPI) DeleteEventSourceMapping(arg0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "DeleteEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteEventSourceMapping(arg0 *lambda.DeleteEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "DeleteEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteEventSourceMapping",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteEventSourceMappingInput",
")",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteEventSourceMapping mocks base method | [
"DeleteEventSourceMapping",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L259-L264 | train |
apex/apex | mock/lambdaiface.go | DeleteEventSourceMappingRequest | func (m *MockLambdaAPI) DeleteEventSourceMappingRequest(arg0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "DeleteEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteEventSourceMappingRequest(arg0 *lambda.DeleteEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "DeleteEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteEventSourceMappingRequest",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteEventSourceMappingInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteEventSourceMappingRequest mocks base method | [
"DeleteEventSourceMappingRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L272-L277 | train |
apex/apex | mock/lambdaiface.go | DeleteFunction | func (m *MockLambdaAPI) DeleteFunction(arg0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunction", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunction(arg0 *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunction", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunction",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteFunctionInput",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunction mocks base method | [
"DeleteFunction",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L303-L308 | train |
apex/apex | mock/lambdaiface.go | DeleteFunctionConcurrency | func (m *MockLambdaAPI) DeleteFunctionConcurrency(arg0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunctionConcurrency(arg0 *lambda.DeleteFunctionConcurrencyInput) (*lambda.DeleteFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunctionConcurrency",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyInput",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunctionConcurrency mocks base method | [
"DeleteFunctionConcurrency",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L316-L321 | train |
apex/apex | mock/lambdaiface.go | DeleteFunctionConcurrencyRequest | func (m *MockLambdaAPI) DeleteFunctionConcurrencyRequest(arg0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionConcurrencyOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunctionConcurrencyRequest(arg0 *lambda.DeleteFunctionConcurrencyInput) (*request.Request, *lambda.DeleteFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionConcurrencyOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunctionConcurrencyRequest",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunctionConcurrencyRequest mocks base method | [
"DeleteFunctionConcurrencyRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L329-L334 | train |
apex/apex | mock/lambdaiface.go | DeleteFunctionConcurrencyWithContext | func (m *MockLambdaAPI) DeleteFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.DeleteFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionConcurrencyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunctionConcurrencyWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionConcurrencyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunctionConcurrencyWithContext mocks base method | [
"DeleteFunctionConcurrencyWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L342-L351 | train |
apex/apex | mock/lambdaiface.go | DeleteFunctionRequest | func (m *MockLambdaAPI) DeleteFunctionRequest(arg0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunctionRequest(arg0 *lambda.DeleteFunctionInput) (*request.Request, *lambda.DeleteFunctionOutput) {
ret := m.ctrl.Call(m, "DeleteFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.DeleteFunctionOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunctionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"DeleteFunctionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"DeleteFunctionOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunctionRequest mocks base method | [
"DeleteFunctionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L360-L365 | train |
apex/apex | mock/lambdaiface.go | DeleteFunctionWithContext | func (m *MockLambdaAPI) DeleteFunctionWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionInput, arg2 ...request.Option) (*lambda.DeleteFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) DeleteFunctionWithContext(arg0 aws.Context, arg1 *lambda.DeleteFunctionInput, arg2 ...request.Option) (*lambda.DeleteFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "DeleteFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.DeleteFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"DeleteFunctionWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"DeleteFunctionInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // DeleteFunctionWithContext mocks base method | [
"DeleteFunctionWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L373-L382 | train |
apex/apex | mock/lambdaiface.go | GetAccountSettings | func (m *MockLambdaAPI) GetAccountSettings(arg0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
ret := m.ctrl.Call(m, "GetAccountSettings", arg0)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetAccountSettings(arg0 *lambda.GetAccountSettingsInput) (*lambda.GetAccountSettingsOutput, error) {
ret := m.ctrl.Call(m, "GetAccountSettings", arg0)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetAccountSettings",
"(",
"arg0",
"*",
"lambda",
".",
"GetAccountSettingsInput",
")",
"(",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAccountSettings mocks base method | [
"GetAccountSettings",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L391-L396 | train |
apex/apex | mock/lambdaiface.go | GetAccountSettingsRequest | func (m *MockLambdaAPI) GetAccountSettingsRequest(arg0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
ret := m.ctrl.Call(m, "GetAccountSettingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetAccountSettingsOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetAccountSettingsRequest(arg0 *lambda.GetAccountSettingsInput) (*request.Request, *lambda.GetAccountSettingsOutput) {
ret := m.ctrl.Call(m, "GetAccountSettingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetAccountSettingsOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetAccountSettingsRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetAccountSettingsInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAccountSettingsRequest mocks base method | [
"GetAccountSettingsRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L404-L409 | train |
apex/apex | mock/lambdaiface.go | GetAccountSettingsWithContext | func (m *MockLambdaAPI) GetAccountSettingsWithContext(arg0 aws.Context, arg1 *lambda.GetAccountSettingsInput, arg2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetAccountSettingsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetAccountSettingsWithContext(arg0 aws.Context, arg1 *lambda.GetAccountSettingsInput, arg2 ...request.Option) (*lambda.GetAccountSettingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetAccountSettingsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetAccountSettingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetAccountSettingsWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"GetAccountSettingsInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetAccountSettingsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAccountSettingsWithContext mocks base method | [
"GetAccountSettingsWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L417-L426 | train |
apex/apex | mock/lambdaiface.go | GetAlias | func (m *MockLambdaAPI) GetAlias(arg0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "GetAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetAlias(arg0 *lambda.GetAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "GetAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetAlias",
"(",
"arg0",
"*",
"lambda",
".",
"GetAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAlias mocks base method | [
"GetAlias",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L435-L440 | train |
apex/apex | mock/lambdaiface.go | GetAliasRequest | func (m *MockLambdaAPI) GetAliasRequest(arg0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "GetAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetAliasRequest(arg0 *lambda.GetAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "GetAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetAliasRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetAliasInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetAliasRequest mocks base method | [
"GetAliasRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L448-L453 | train |
apex/apex | mock/lambdaiface.go | GetEventSourceMapping | func (m *MockLambdaAPI) GetEventSourceMapping(arg0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "GetEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetEventSourceMapping(arg0 *lambda.GetEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "GetEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetEventSourceMapping",
"(",
"arg0",
"*",
"lambda",
".",
"GetEventSourceMappingInput",
")",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetEventSourceMapping mocks base method | [
"GetEventSourceMapping",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L479-L484 | train |
apex/apex | mock/lambdaiface.go | GetEventSourceMappingRequest | func (m *MockLambdaAPI) GetEventSourceMappingRequest(arg0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "GetEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetEventSourceMappingRequest(arg0 *lambda.GetEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "GetEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetEventSourceMappingRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetEventSourceMappingInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetEventSourceMappingRequest mocks base method | [
"GetEventSourceMappingRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L492-L497 | train |
apex/apex | mock/lambdaiface.go | GetFunction | func (m *MockLambdaAPI) GetFunction(arg0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
ret := m.ctrl.Call(m, "GetFunction", arg0)
ret0, _ := ret[0].(*lambda.GetFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunction(arg0 *lambda.GetFunctionInput) (*lambda.GetFunctionOutput, error) {
ret := m.ctrl.Call(m, "GetFunction", arg0)
ret0, _ := ret[0].(*lambda.GetFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunction",
"(",
"arg0",
"*",
"lambda",
".",
"GetFunctionInput",
")",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunction mocks base method | [
"GetFunction",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L523-L528 | train |
apex/apex | mock/lambdaiface.go | GetFunctionConfiguration | func (m *MockLambdaAPI) GetFunctionConfiguration(arg0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "GetFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunctionConfiguration(arg0 *lambda.GetFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "GetFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunctionConfiguration",
"(",
"arg0",
"*",
"lambda",
".",
"GetFunctionConfigurationInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunctionConfiguration mocks base method | [
"GetFunctionConfiguration",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L536-L541 | train |
apex/apex | mock/lambdaiface.go | GetFunctionConfigurationRequest | func (m *MockLambdaAPI) GetFunctionConfigurationRequest(arg0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "GetFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunctionConfigurationRequest(arg0 *lambda.GetFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "GetFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunctionConfigurationRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetFunctionConfigurationInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunctionConfigurationRequest mocks base method | [
"GetFunctionConfigurationRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L549-L554 | train |
apex/apex | mock/lambdaiface.go | GetFunctionConfigurationWithContext | func (m *MockLambdaAPI) GetFunctionConfigurationWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionConfigurationInput, arg2 ...request.Option) (*lambda.FunctionConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunctionConfigurationWithContext", varargs...)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunctionConfigurationWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionConfigurationInput, arg2 ...request.Option) (*lambda.FunctionConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunctionConfigurationWithContext", varargs...)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunctionConfigurationWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"GetFunctionConfigurationInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunctionConfigurationWithContext mocks base method | [
"GetFunctionConfigurationWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L562-L571 | train |
apex/apex | mock/lambdaiface.go | GetFunctionRequest | func (m *MockLambdaAPI) GetFunctionRequest(arg0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
ret := m.ctrl.Call(m, "GetFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetFunctionOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunctionRequest(arg0 *lambda.GetFunctionInput) (*request.Request, *lambda.GetFunctionOutput) {
ret := m.ctrl.Call(m, "GetFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetFunctionOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunctionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetFunctionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunctionRequest mocks base method | [
"GetFunctionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L580-L585 | train |
apex/apex | mock/lambdaiface.go | GetFunctionWithContext | func (m *MockLambdaAPI) GetFunctionWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionInput, arg2 ...request.Option) (*lambda.GetFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetFunctionWithContext(arg0 aws.Context, arg1 *lambda.GetFunctionInput, arg2 ...request.Option) (*lambda.GetFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetFunctionWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"GetFunctionInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetFunctionWithContext mocks base method | [
"GetFunctionWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L593-L602 | train |
apex/apex | mock/lambdaiface.go | GetPolicy | func (m *MockLambdaAPI) GetPolicy(arg0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
ret := m.ctrl.Call(m, "GetPolicy", arg0)
ret0, _ := ret[0].(*lambda.GetPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetPolicy(arg0 *lambda.GetPolicyInput) (*lambda.GetPolicyOutput, error) {
ret := m.ctrl.Call(m, "GetPolicy", arg0)
ret0, _ := ret[0].(*lambda.GetPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetPolicy",
"(",
"arg0",
"*",
"lambda",
".",
"GetPolicyInput",
")",
"(",
"*",
"lambda",
".",
"GetPolicyOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetPolicyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetPolicy mocks base method | [
"GetPolicy",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L611-L616 | train |
apex/apex | mock/lambdaiface.go | GetPolicyRequest | func (m *MockLambdaAPI) GetPolicyRequest(arg0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
ret := m.ctrl.Call(m, "GetPolicyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetPolicyOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetPolicyRequest(arg0 *lambda.GetPolicyInput) (*request.Request, *lambda.GetPolicyOutput) {
ret := m.ctrl.Call(m, "GetPolicyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.GetPolicyOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetPolicyRequest",
"(",
"arg0",
"*",
"lambda",
".",
"GetPolicyInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"GetPolicyOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"GetPolicyOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetPolicyRequest mocks base method | [
"GetPolicyRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L624-L629 | train |
apex/apex | mock/lambdaiface.go | GetPolicyWithContext | func (m *MockLambdaAPI) GetPolicyWithContext(arg0 aws.Context, arg1 *lambda.GetPolicyInput, arg2 ...request.Option) (*lambda.GetPolicyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPolicyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) GetPolicyWithContext(arg0 aws.Context, arg1 *lambda.GetPolicyInput, arg2 ...request.Option) (*lambda.GetPolicyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "GetPolicyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.GetPolicyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"GetPolicyWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"GetPolicyInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"GetPolicyOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"GetPolicyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // GetPolicyWithContext mocks base method | [
"GetPolicyWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L637-L646 | train |
apex/apex | mock/lambdaiface.go | Invoke | func (m *MockLambdaAPI) Invoke(arg0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
ret := m.ctrl.Call(m, "Invoke", arg0)
ret0, _ := ret[0].(*lambda.InvokeOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) Invoke(arg0 *lambda.InvokeInput) (*lambda.InvokeOutput, error) {
ret := m.ctrl.Call(m, "Invoke", arg0)
ret0, _ := ret[0].(*lambda.InvokeOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"Invoke",
"(",
"arg0",
"*",
"lambda",
".",
"InvokeInput",
")",
"(",
"*",
"lambda",
".",
"InvokeOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // Invoke mocks base method | [
"Invoke",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L655-L660 | train |
apex/apex | mock/lambdaiface.go | InvokeAsync | func (m *MockLambdaAPI) InvokeAsync(arg0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
ret := m.ctrl.Call(m, "InvokeAsync", arg0)
ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) InvokeAsync(arg0 *lambda.InvokeAsyncInput) (*lambda.InvokeAsyncOutput, error) {
ret := m.ctrl.Call(m, "InvokeAsync", arg0)
ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"InvokeAsync",
"(",
"arg0",
"*",
"lambda",
".",
"InvokeAsyncInput",
")",
"(",
"*",
"lambda",
".",
"InvokeAsyncOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeAsyncOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // InvokeAsync mocks base method | [
"InvokeAsync",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L668-L673 | train |
apex/apex | mock/lambdaiface.go | InvokeAsyncRequest | func (m *MockLambdaAPI) InvokeAsyncRequest(arg0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
ret := m.ctrl.Call(m, "InvokeAsyncRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeAsyncOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) InvokeAsyncRequest(arg0 *lambda.InvokeAsyncInput) (*request.Request, *lambda.InvokeAsyncOutput) {
ret := m.ctrl.Call(m, "InvokeAsyncRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeAsyncOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"InvokeAsyncRequest",
"(",
"arg0",
"*",
"lambda",
".",
"InvokeAsyncInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"InvokeAsyncOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeAsyncOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // InvokeAsyncRequest mocks base method | [
"InvokeAsyncRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L681-L686 | train |
apex/apex | mock/lambdaiface.go | InvokeAsyncWithContext | func (m *MockLambdaAPI) InvokeAsyncWithContext(arg0 aws.Context, arg1 *lambda.InvokeAsyncInput, arg2 ...request.Option) (*lambda.InvokeAsyncOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeAsyncWithContext", varargs...)
ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) InvokeAsyncWithContext(arg0 aws.Context, arg1 *lambda.InvokeAsyncInput, arg2 ...request.Option) (*lambda.InvokeAsyncOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeAsyncWithContext", varargs...)
ret0, _ := ret[0].(*lambda.InvokeAsyncOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"InvokeAsyncWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"InvokeAsyncInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"InvokeAsyncOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeAsyncOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // InvokeAsyncWithContext mocks base method | [
"InvokeAsyncWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L694-L703 | train |
apex/apex | mock/lambdaiface.go | InvokeRequest | func (m *MockLambdaAPI) InvokeRequest(arg0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
ret := m.ctrl.Call(m, "InvokeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) InvokeRequest(arg0 *lambda.InvokeInput) (*request.Request, *lambda.InvokeOutput) {
ret := m.ctrl.Call(m, "InvokeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.InvokeOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"InvokeRequest",
"(",
"arg0",
"*",
"lambda",
".",
"InvokeInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"InvokeOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // InvokeRequest mocks base method | [
"InvokeRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L712-L717 | train |
apex/apex | mock/lambdaiface.go | InvokeWithContext | func (m *MockLambdaAPI) InvokeWithContext(arg0 aws.Context, arg1 *lambda.InvokeInput, arg2 ...request.Option) (*lambda.InvokeOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeWithContext", varargs...)
ret0, _ := ret[0].(*lambda.InvokeOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) InvokeWithContext(arg0 aws.Context, arg1 *lambda.InvokeInput, arg2 ...request.Option) (*lambda.InvokeOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "InvokeWithContext", varargs...)
ret0, _ := ret[0].(*lambda.InvokeOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"InvokeWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"InvokeInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"InvokeOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"InvokeOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // InvokeWithContext mocks base method | [
"InvokeWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L725-L734 | train |
apex/apex | mock/lambdaiface.go | ListAliases | func (m *MockLambdaAPI) ListAliases(arg0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
ret := m.ctrl.Call(m, "ListAliases", arg0)
ret0, _ := ret[0].(*lambda.ListAliasesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListAliases(arg0 *lambda.ListAliasesInput) (*lambda.ListAliasesOutput, error) {
ret := m.ctrl.Call(m, "ListAliases", arg0)
ret0, _ := ret[0].(*lambda.ListAliasesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListAliases",
"(",
"arg0",
"*",
"lambda",
".",
"ListAliasesInput",
")",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListAliases mocks base method | [
"ListAliases",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L743-L748 | train |
apex/apex | mock/lambdaiface.go | ListAliasesRequest | func (m *MockLambdaAPI) ListAliasesRequest(arg0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListAliasesOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListAliasesRequest(arg0 *lambda.ListAliasesInput) (*request.Request, *lambda.ListAliasesOutput) {
ret := m.ctrl.Call(m, "ListAliasesRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListAliasesOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListAliasesRequest",
"(",
"arg0",
"*",
"lambda",
".",
"ListAliasesInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"ListAliasesOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListAliasesRequest mocks base method | [
"ListAliasesRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L756-L761 | train |
apex/apex | mock/lambdaiface.go | ListAliasesRequest | func (mr *MockLambdaAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesRequest), arg0)
} | go | func (mr *MockLambdaAPIMockRecorder) ListAliasesRequest(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesRequest", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesRequest), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockLambdaAPIMockRecorder",
")",
"ListAliasesRequest",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockLambdaAPI",
")",
"(",
"nil",
")",
".",
"ListAliasesRequest",
")",
",",
"arg0",
")",
"\n",
"}"
] | // ListAliasesRequest indicates an expected call of ListAliasesRequest | [
"ListAliasesRequest",
"indicates",
"an",
"expected",
"call",
"of",
"ListAliasesRequest"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L764-L766 | train |
apex/apex | mock/lambdaiface.go | ListAliasesWithContext | func (m *MockLambdaAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *lambda.ListAliasesInput, arg2 ...request.Option) (*lambda.ListAliasesOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListAliasesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListAliasesWithContext(arg0 aws.Context, arg1 *lambda.ListAliasesInput, arg2 ...request.Option) (*lambda.ListAliasesOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListAliasesWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListAliasesOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListAliasesWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"ListAliasesInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListAliasesOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListAliasesWithContext mocks base method | [
"ListAliasesWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L769-L778 | train |
apex/apex | mock/lambdaiface.go | ListAliasesWithContext | func (mr *MockLambdaAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesWithContext), varargs...)
} | go | func (mr *MockLambdaAPIMockRecorder) ListAliasesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
varargs := append([]interface{}{arg0, arg1}, arg2...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAliasesWithContext", reflect.TypeOf((*MockLambdaAPI)(nil).ListAliasesWithContext), varargs...)
} | [
"func",
"(",
"mr",
"*",
"MockLambdaAPIMockRecorder",
")",
"ListAliasesWithContext",
"(",
"arg0",
",",
"arg1",
"interface",
"{",
"}",
",",
"arg2",
"...",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"varargs",
":=",
"append",
"(",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
",",
"arg2",
"...",
")",
"\n",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"",
"\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockLambdaAPI",
")",
"(",
"nil",
")",
".",
"ListAliasesWithContext",
")",
",",
"varargs",
"...",
")",
"\n",
"}"
] | // ListAliasesWithContext indicates an expected call of ListAliasesWithContext | [
"ListAliasesWithContext",
"indicates",
"an",
"expected",
"call",
"of",
"ListAliasesWithContext"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L781-L784 | train |
apex/apex | mock/lambdaiface.go | ListEventSourceMappings | func (m *MockLambdaAPI) ListEventSourceMappings(arg0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
ret := m.ctrl.Call(m, "ListEventSourceMappings", arg0)
ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListEventSourceMappings(arg0 *lambda.ListEventSourceMappingsInput) (*lambda.ListEventSourceMappingsOutput, error) {
ret := m.ctrl.Call(m, "ListEventSourceMappings", arg0)
ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListEventSourceMappings",
"(",
"arg0",
"*",
"lambda",
".",
"ListEventSourceMappingsInput",
")",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListEventSourceMappings mocks base method | [
"ListEventSourceMappings",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L787-L792 | train |
apex/apex | mock/lambdaiface.go | ListEventSourceMappingsPages | func (m *MockLambdaAPI) ListEventSourceMappingsPages(arg0 *lambda.ListEventSourceMappingsInput, arg1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListEventSourceMappingsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockLambdaAPI) ListEventSourceMappingsPages(arg0 *lambda.ListEventSourceMappingsInput, arg1 func(*lambda.ListEventSourceMappingsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListEventSourceMappingsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListEventSourceMappingsPages",
"(",
"arg0",
"*",
"lambda",
".",
"ListEventSourceMappingsInput",
",",
"arg1",
"func",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
",",
"bool",
")",
"bool",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ListEventSourceMappingsPages mocks base method | [
"ListEventSourceMappingsPages",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L800-L804 | train |
apex/apex | mock/lambdaiface.go | ListEventSourceMappingsRequest | func (m *MockLambdaAPI) ListEventSourceMappingsRequest(arg0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
ret := m.ctrl.Call(m, "ListEventSourceMappingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListEventSourceMappingsOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListEventSourceMappingsRequest(arg0 *lambda.ListEventSourceMappingsInput) (*request.Request, *lambda.ListEventSourceMappingsOutput) {
ret := m.ctrl.Call(m, "ListEventSourceMappingsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListEventSourceMappingsOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListEventSourceMappingsRequest",
"(",
"arg0",
"*",
"lambda",
".",
"ListEventSourceMappingsInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListEventSourceMappingsRequest mocks base method | [
"ListEventSourceMappingsRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L829-L834 | train |
apex/apex | mock/lambdaiface.go | ListEventSourceMappingsWithContext | func (m *MockLambdaAPI) ListEventSourceMappingsWithContext(arg0 aws.Context, arg1 *lambda.ListEventSourceMappingsInput, arg2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListEventSourceMappingsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListEventSourceMappingsWithContext(arg0 aws.Context, arg1 *lambda.ListEventSourceMappingsInput, arg2 ...request.Option) (*lambda.ListEventSourceMappingsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListEventSourceMappingsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListEventSourceMappingsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListEventSourceMappingsWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"ListEventSourceMappingsInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListEventSourceMappingsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListEventSourceMappingsWithContext mocks base method | [
"ListEventSourceMappingsWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L842-L851 | train |
apex/apex | mock/lambdaiface.go | ListFunctions | func (m *MockLambdaAPI) ListFunctions(arg0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
ret := m.ctrl.Call(m, "ListFunctions", arg0)
ret0, _ := ret[0].(*lambda.ListFunctionsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListFunctions(arg0 *lambda.ListFunctionsInput) (*lambda.ListFunctionsOutput, error) {
ret := m.ctrl.Call(m, "ListFunctions", arg0)
ret0, _ := ret[0].(*lambda.ListFunctionsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListFunctions",
"(",
"arg0",
"*",
"lambda",
".",
"ListFunctionsInput",
")",
"(",
"*",
"lambda",
".",
"ListFunctionsOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListFunctionsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListFunctions mocks base method | [
"ListFunctions",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L860-L865 | train |
apex/apex | mock/lambdaiface.go | ListFunctionsPages | func (m *MockLambdaAPI) ListFunctionsPages(arg0 *lambda.ListFunctionsInput, arg1 func(*lambda.ListFunctionsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListFunctionsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockLambdaAPI) ListFunctionsPages(arg0 *lambda.ListFunctionsInput, arg1 func(*lambda.ListFunctionsOutput, bool) bool) error {
ret := m.ctrl.Call(m, "ListFunctionsPages", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListFunctionsPages",
"(",
"arg0",
"*",
"lambda",
".",
"ListFunctionsInput",
",",
"arg1",
"func",
"(",
"*",
"lambda",
".",
"ListFunctionsOutput",
",",
"bool",
")",
"bool",
")",
"error",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
",",
"arg1",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ListFunctionsPages mocks base method | [
"ListFunctionsPages",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L873-L877 | train |
apex/apex | mock/lambdaiface.go | ListFunctionsPagesWithContext | func (m *MockLambdaAPI) ListFunctionsPagesWithContext(arg0 aws.Context, arg1 *lambda.ListFunctionsInput, arg2 func(*lambda.ListFunctionsOutput, bool) bool, arg3 ...request.Option) error {
varargs := []interface{}{arg0, arg1, arg2}
for _, a := range arg3 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListFunctionsPagesWithContext", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | go | func (m *MockLambdaAPI) ListFunctionsPagesWithContext(arg0 aws.Context, arg1 *lambda.ListFunctionsInput, arg2 func(*lambda.ListFunctionsOutput, bool) bool, arg3 ...request.Option) error {
varargs := []interface{}{arg0, arg1, arg2}
for _, a := range arg3 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListFunctionsPagesWithContext", varargs...)
ret0, _ := ret[0].(error)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListFunctionsPagesWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"ListFunctionsInput",
",",
"arg2",
"func",
"(",
"*",
"lambda",
".",
"ListFunctionsOutput",
",",
"bool",
")",
"bool",
",",
"arg3",
"...",
"request",
".",
"Option",
")",
"error",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
",",
"arg2",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg3",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // ListFunctionsPagesWithContext mocks base method | [
"ListFunctionsPagesWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L885-L893 | train |
apex/apex | mock/lambdaiface.go | ListFunctionsRequest | func (m *MockLambdaAPI) ListFunctionsRequest(arg0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
ret := m.ctrl.Call(m, "ListFunctionsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListFunctionsOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListFunctionsRequest(arg0 *lambda.ListFunctionsInput) (*request.Request, *lambda.ListFunctionsOutput) {
ret := m.ctrl.Call(m, "ListFunctionsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListFunctionsOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListFunctionsRequest",
"(",
"arg0",
"*",
"lambda",
".",
"ListFunctionsInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"ListFunctionsOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"ListFunctionsOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListFunctionsRequest mocks base method | [
"ListFunctionsRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L902-L907 | train |
apex/apex | mock/lambdaiface.go | ListTags | func (m *MockLambdaAPI) ListTags(arg0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
ret := m.ctrl.Call(m, "ListTags", arg0)
ret0, _ := ret[0].(*lambda.ListTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListTags(arg0 *lambda.ListTagsInput) (*lambda.ListTagsOutput, error) {
ret := m.ctrl.Call(m, "ListTags", arg0)
ret0, _ := ret[0].(*lambda.ListTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListTags",
"(",
"arg0",
"*",
"lambda",
".",
"ListTagsInput",
")",
"(",
"*",
"lambda",
".",
"ListTagsOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListTagsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListTags mocks base method | [
"ListTags",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L933-L938 | train |
apex/apex | mock/lambdaiface.go | ListTagsRequest | func (m *MockLambdaAPI) ListTagsRequest(arg0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
ret := m.ctrl.Call(m, "ListTagsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListTagsOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListTagsRequest(arg0 *lambda.ListTagsInput) (*request.Request, *lambda.ListTagsOutput) {
ret := m.ctrl.Call(m, "ListTagsRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListTagsOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListTagsRequest",
"(",
"arg0",
"*",
"lambda",
".",
"ListTagsInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"ListTagsOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"ListTagsOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListTagsRequest mocks base method | [
"ListTagsRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L946-L951 | train |
apex/apex | mock/lambdaiface.go | ListTagsWithContext | func (m *MockLambdaAPI) ListTagsWithContext(arg0 aws.Context, arg1 *lambda.ListTagsInput, arg2 ...request.Option) (*lambda.ListTagsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListTagsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListTagsWithContext(arg0 aws.Context, arg1 *lambda.ListTagsInput, arg2 ...request.Option) (*lambda.ListTagsOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListTagsWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListTagsOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListTagsWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"ListTagsInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"ListTagsOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListTagsOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListTagsWithContext mocks base method | [
"ListTagsWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L959-L968 | train |
apex/apex | mock/lambdaiface.go | ListVersionsByFunction | func (m *MockLambdaAPI) ListVersionsByFunction(arg0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
ret := m.ctrl.Call(m, "ListVersionsByFunction", arg0)
ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListVersionsByFunction(arg0 *lambda.ListVersionsByFunctionInput) (*lambda.ListVersionsByFunctionOutput, error) {
ret := m.ctrl.Call(m, "ListVersionsByFunction", arg0)
ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListVersionsByFunction",
"(",
"arg0",
"*",
"lambda",
".",
"ListVersionsByFunctionInput",
")",
"(",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListVersionsByFunction mocks base method | [
"ListVersionsByFunction",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L977-L982 | train |
apex/apex | mock/lambdaiface.go | ListVersionsByFunctionRequest | func (m *MockLambdaAPI) ListVersionsByFunctionRequest(arg0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
ret := m.ctrl.Call(m, "ListVersionsByFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListVersionsByFunctionOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListVersionsByFunctionRequest(arg0 *lambda.ListVersionsByFunctionInput) (*request.Request, *lambda.ListVersionsByFunctionOutput) {
ret := m.ctrl.Call(m, "ListVersionsByFunctionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.ListVersionsByFunctionOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListVersionsByFunctionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"ListVersionsByFunctionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListVersionsByFunctionRequest mocks base method | [
"ListVersionsByFunctionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L990-L995 | train |
apex/apex | mock/lambdaiface.go | ListVersionsByFunctionWithContext | func (m *MockLambdaAPI) ListVersionsByFunctionWithContext(arg0 aws.Context, arg1 *lambda.ListVersionsByFunctionInput, arg2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListVersionsByFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) ListVersionsByFunctionWithContext(arg0 aws.Context, arg1 *lambda.ListVersionsByFunctionInput, arg2 ...request.Option) (*lambda.ListVersionsByFunctionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "ListVersionsByFunctionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.ListVersionsByFunctionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"ListVersionsByFunctionWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"ListVersionsByFunctionInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"ListVersionsByFunctionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // ListVersionsByFunctionWithContext mocks base method | [
"ListVersionsByFunctionWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1003-L1012 | train |
apex/apex | mock/lambdaiface.go | PublishVersion | func (m *MockLambdaAPI) PublishVersion(arg0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "PublishVersion", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) PublishVersion(arg0 *lambda.PublishVersionInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "PublishVersion", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"PublishVersion",
"(",
"arg0",
"*",
"lambda",
".",
"PublishVersionInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PublishVersion mocks base method | [
"PublishVersion",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1021-L1026 | train |
apex/apex | mock/lambdaiface.go | PublishVersionRequest | func (m *MockLambdaAPI) PublishVersionRequest(arg0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "PublishVersionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) PublishVersionRequest(arg0 *lambda.PublishVersionInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "PublishVersionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"PublishVersionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"PublishVersionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PublishVersionRequest mocks base method | [
"PublishVersionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1034-L1039 | train |
apex/apex | mock/lambdaiface.go | PutFunctionConcurrency | func (m *MockLambdaAPI) PutFunctionConcurrency(arg0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "PutFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) PutFunctionConcurrency(arg0 *lambda.PutFunctionConcurrencyInput) (*lambda.PutFunctionConcurrencyOutput, error) {
ret := m.ctrl.Call(m, "PutFunctionConcurrency", arg0)
ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"PutFunctionConcurrency",
"(",
"arg0",
"*",
"lambda",
".",
"PutFunctionConcurrencyInput",
")",
"(",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PutFunctionConcurrency mocks base method | [
"PutFunctionConcurrency",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1065-L1070 | train |
apex/apex | mock/lambdaiface.go | PutFunctionConcurrencyRequest | func (m *MockLambdaAPI) PutFunctionConcurrencyRequest(arg0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "PutFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.PutFunctionConcurrencyOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) PutFunctionConcurrencyRequest(arg0 *lambda.PutFunctionConcurrencyInput) (*request.Request, *lambda.PutFunctionConcurrencyOutput) {
ret := m.ctrl.Call(m, "PutFunctionConcurrencyRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.PutFunctionConcurrencyOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"PutFunctionConcurrencyRequest",
"(",
"arg0",
"*",
"lambda",
".",
"PutFunctionConcurrencyInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PutFunctionConcurrencyRequest mocks base method | [
"PutFunctionConcurrencyRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1078-L1083 | train |
apex/apex | mock/lambdaiface.go | PutFunctionConcurrencyWithContext | func (m *MockLambdaAPI) PutFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.PutFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PutFunctionConcurrencyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) PutFunctionConcurrencyWithContext(arg0 aws.Context, arg1 *lambda.PutFunctionConcurrencyInput, arg2 ...request.Option) (*lambda.PutFunctionConcurrencyOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "PutFunctionConcurrencyWithContext", varargs...)
ret0, _ := ret[0].(*lambda.PutFunctionConcurrencyOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"PutFunctionConcurrencyWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"PutFunctionConcurrencyInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"PutFunctionConcurrencyOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // PutFunctionConcurrencyWithContext mocks base method | [
"PutFunctionConcurrencyWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1091-L1100 | train |
apex/apex | mock/lambdaiface.go | RemovePermission | func (m *MockLambdaAPI) RemovePermission(arg0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
ret := m.ctrl.Call(m, "RemovePermission", arg0)
ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) RemovePermission(arg0 *lambda.RemovePermissionInput) (*lambda.RemovePermissionOutput, error) {
ret := m.ctrl.Call(m, "RemovePermission", arg0)
ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"RemovePermission",
"(",
"arg0",
"*",
"lambda",
".",
"RemovePermissionInput",
")",
"(",
"*",
"lambda",
".",
"RemovePermissionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"RemovePermissionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // RemovePermission mocks base method | [
"RemovePermission",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1109-L1114 | train |
apex/apex | mock/lambdaiface.go | RemovePermissionRequest | func (m *MockLambdaAPI) RemovePermissionRequest(arg0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.RemovePermissionOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) RemovePermissionRequest(arg0 *lambda.RemovePermissionInput) (*request.Request, *lambda.RemovePermissionOutput) {
ret := m.ctrl.Call(m, "RemovePermissionRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.RemovePermissionOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"RemovePermissionRequest",
"(",
"arg0",
"*",
"lambda",
".",
"RemovePermissionInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"RemovePermissionOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"RemovePermissionOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // RemovePermissionRequest mocks base method | [
"RemovePermissionRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1122-L1127 | train |
apex/apex | mock/lambdaiface.go | RemovePermissionWithContext | func (m *MockLambdaAPI) RemovePermissionWithContext(arg0 aws.Context, arg1 *lambda.RemovePermissionInput, arg2 ...request.Option) (*lambda.RemovePermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) RemovePermissionWithContext(arg0 aws.Context, arg1 *lambda.RemovePermissionInput, arg2 ...request.Option) (*lambda.RemovePermissionOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "RemovePermissionWithContext", varargs...)
ret0, _ := ret[0].(*lambda.RemovePermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"RemovePermissionWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"RemovePermissionInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"RemovePermissionOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"RemovePermissionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // RemovePermissionWithContext mocks base method | [
"RemovePermissionWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1135-L1144 | train |
apex/apex | mock/lambdaiface.go | TagResource | func (m *MockLambdaAPI) TagResource(arg0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
ret := m.ctrl.Call(m, "TagResource", arg0)
ret0, _ := ret[0].(*lambda.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) TagResource(arg0 *lambda.TagResourceInput) (*lambda.TagResourceOutput, error) {
ret := m.ctrl.Call(m, "TagResource", arg0)
ret0, _ := ret[0].(*lambda.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"TagResource",
"(",
"arg0",
"*",
"lambda",
".",
"TagResourceInput",
")",
"(",
"*",
"lambda",
".",
"TagResourceOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"TagResourceOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // TagResource mocks base method | [
"TagResource",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1153-L1158 | train |
apex/apex | mock/lambdaiface.go | TagResourceRequest | func (m *MockLambdaAPI) TagResourceRequest(arg0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.TagResourceOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) TagResourceRequest(arg0 *lambda.TagResourceInput) (*request.Request, *lambda.TagResourceOutput) {
ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.TagResourceOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"TagResourceRequest",
"(",
"arg0",
"*",
"lambda",
".",
"TagResourceInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"TagResourceOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"TagResourceOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // TagResourceRequest mocks base method | [
"TagResourceRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1166-L1171 | train |
apex/apex | mock/lambdaiface.go | TagResourceWithContext | func (m *MockLambdaAPI) TagResourceWithContext(arg0 aws.Context, arg1 *lambda.TagResourceInput, arg2 ...request.Option) (*lambda.TagResourceOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
ret0, _ := ret[0].(*lambda.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) TagResourceWithContext(arg0 aws.Context, arg1 *lambda.TagResourceInput, arg2 ...request.Option) (*lambda.TagResourceOutput, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
ret0, _ := ret[0].(*lambda.TagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"TagResourceWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"TagResourceInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"TagResourceOutput",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"TagResourceOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // TagResourceWithContext mocks base method | [
"TagResourceWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1179-L1188 | train |
apex/apex | mock/lambdaiface.go | UntagResource | func (m *MockLambdaAPI) UntagResource(arg0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
ret := m.ctrl.Call(m, "UntagResource", arg0)
ret0, _ := ret[0].(*lambda.UntagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UntagResource(arg0 *lambda.UntagResourceInput) (*lambda.UntagResourceOutput, error) {
ret := m.ctrl.Call(m, "UntagResource", arg0)
ret0, _ := ret[0].(*lambda.UntagResourceOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UntagResource",
"(",
"arg0",
"*",
"lambda",
".",
"UntagResourceInput",
")",
"(",
"*",
"lambda",
".",
"UntagResourceOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"UntagResourceOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UntagResource mocks base method | [
"UntagResource",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1197-L1202 | train |
apex/apex | mock/lambdaiface.go | UntagResourceRequest | func (m *MockLambdaAPI) UntagResourceRequest(arg0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.UntagResourceOutput)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UntagResourceRequest(arg0 *lambda.UntagResourceInput) (*request.Request, *lambda.UntagResourceOutput) {
ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.UntagResourceOutput)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UntagResourceRequest",
"(",
"arg0",
"*",
"lambda",
".",
"UntagResourceInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"UntagResourceOutput",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"UntagResourceOutput",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UntagResourceRequest mocks base method | [
"UntagResourceRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1210-L1215 | train |
apex/apex | mock/lambdaiface.go | UpdateAlias | func (m *MockLambdaAPI) UpdateAlias(arg0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateAlias(arg0 *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateAlias", arg0)
ret0, _ := ret[0].(*lambda.AliasConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateAlias",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateAlias mocks base method | [
"UpdateAlias",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1241-L1246 | train |
apex/apex | mock/lambdaiface.go | UpdateAliasRequest | func (m *MockLambdaAPI) UpdateAliasRequest(arg0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateAliasRequest(arg0 *lambda.UpdateAliasInput) (*request.Request, *lambda.AliasConfiguration) {
ret := m.ctrl.Call(m, "UpdateAliasRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.AliasConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateAliasRequest",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateAliasInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateAliasRequest mocks base method | [
"UpdateAliasRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1254-L1259 | train |
apex/apex | mock/lambdaiface.go | UpdateEventSourceMapping | func (m *MockLambdaAPI) UpdateEventSourceMapping(arg0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateEventSourceMapping(arg0 *lambda.UpdateEventSourceMappingInput) (*lambda.EventSourceMappingConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateEventSourceMapping", arg0)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateEventSourceMapping",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateEventSourceMappingInput",
")",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateEventSourceMapping mocks base method | [
"UpdateEventSourceMapping",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1285-L1290 | train |
apex/apex | mock/lambdaiface.go | UpdateEventSourceMappingRequest | func (m *MockLambdaAPI) UpdateEventSourceMappingRequest(arg0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "UpdateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateEventSourceMappingRequest(arg0 *lambda.UpdateEventSourceMappingInput) (*request.Request, *lambda.EventSourceMappingConfiguration) {
ret := m.ctrl.Call(m, "UpdateEventSourceMappingRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.EventSourceMappingConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateEventSourceMappingRequest",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateEventSourceMappingInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateEventSourceMappingRequest mocks base method | [
"UpdateEventSourceMappingRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1298-L1303 | train |
apex/apex | mock/lambdaiface.go | UpdateEventSourceMappingWithContext | func (m *MockLambdaAPI) UpdateEventSourceMappingWithContext(arg0 aws.Context, arg1 *lambda.UpdateEventSourceMappingInput, arg2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateEventSourceMappingWithContext", varargs...)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateEventSourceMappingWithContext(arg0 aws.Context, arg1 *lambda.UpdateEventSourceMappingInput, arg2 ...request.Option) (*lambda.EventSourceMappingConfiguration, error) {
varargs := []interface{}{arg0, arg1}
for _, a := range arg2 {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "UpdateEventSourceMappingWithContext", varargs...)
ret0, _ := ret[0].(*lambda.EventSourceMappingConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateEventSourceMappingWithContext",
"(",
"arg0",
"aws",
".",
"Context",
",",
"arg1",
"*",
"lambda",
".",
"UpdateEventSourceMappingInput",
",",
"arg2",
"...",
"request",
".",
"Option",
")",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
",",
"error",
")",
"{",
"varargs",
":=",
"[",
"]",
"interface",
"{",
"}",
"{",
"arg0",
",",
"arg1",
"}",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"arg2",
"{",
"varargs",
"=",
"append",
"(",
"varargs",
",",
"a",
")",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"varargs",
"...",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"EventSourceMappingConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateEventSourceMappingWithContext mocks base method | [
"UpdateEventSourceMappingWithContext",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1311-L1320 | train |
apex/apex | mock/lambdaiface.go | UpdateFunctionCode | func (m *MockLambdaAPI) UpdateFunctionCode(arg0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionCode", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateFunctionCode(arg0 *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionCode", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateFunctionCode",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateFunctionCodeInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateFunctionCode mocks base method | [
"UpdateFunctionCode",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1329-L1334 | train |
apex/apex | mock/lambdaiface.go | UpdateFunctionCodeRequest | func (m *MockLambdaAPI) UpdateFunctionCodeRequest(arg0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionCodeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateFunctionCodeRequest(arg0 *lambda.UpdateFunctionCodeInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionCodeRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateFunctionCodeRequest",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateFunctionCodeInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateFunctionCodeRequest mocks base method | [
"UpdateFunctionCodeRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1342-L1347 | train |
apex/apex | mock/lambdaiface.go | UpdateFunctionConfiguration | func (m *MockLambdaAPI) UpdateFunctionConfiguration(arg0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateFunctionConfiguration(arg0 *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
ret := m.ctrl.Call(m, "UpdateFunctionConfiguration", arg0)
ret0, _ := ret[0].(*lambda.FunctionConfiguration)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateFunctionConfiguration",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateFunctionConfigurationInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateFunctionConfiguration mocks base method | [
"UpdateFunctionConfiguration",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1373-L1378 | train |
apex/apex | mock/lambdaiface.go | UpdateFunctionConfigurationRequest | func (m *MockLambdaAPI) UpdateFunctionConfigurationRequest(arg0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | go | func (m *MockLambdaAPI) UpdateFunctionConfigurationRequest(arg0 *lambda.UpdateFunctionConfigurationInput) (*request.Request, *lambda.FunctionConfiguration) {
ret := m.ctrl.Call(m, "UpdateFunctionConfigurationRequest", arg0)
ret0, _ := ret[0].(*request.Request)
ret1, _ := ret[1].(*lambda.FunctionConfiguration)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"UpdateFunctionConfigurationRequest",
"(",
"arg0",
"*",
"lambda",
".",
"UpdateFunctionConfigurationInput",
")",
"(",
"*",
"request",
".",
"Request",
",",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"",
"\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"request",
".",
"Request",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // UpdateFunctionConfigurationRequest mocks base method | [
"UpdateFunctionConfigurationRequest",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L1386-L1391 | train |
apex/apex | upgrade/upgrade.go | Upgrade | func Upgrade(version string) error {
term.HideCursor()
defer term.ShowCursor()
p := &update.Manager{
Command: "apex",
Store: &github.Store{
Owner: "apex",
Repo: "apex",
Version: version,
},
}
// fetch releases
releases, err := p.LatestReleases()
if err != nil {
return errors.Wrap(err, "fetching latest release")
}
// no updates
if len(releases) == 0 {
util.LogPad("No updates available, you're good :)")
return nil
}
// latest
r := releases[0]
// find the tarball for this system
a := r.FindTarball(runtime.GOOS, runtime.GOARCH)
if a == nil {
return errors.Errorf("failed to find a binary for %s %s", runtime.GOOS, runtime.GOARCH)
}
// download tarball to a tmp dir
tarball, err := a.DownloadProxy(progressreader.New)
if err != nil {
return errors.Wrap(err, "downloading tarball")
}
// install it
if err := p.Install(tarball); err != nil {
return errors.Wrap(err, "installing")
}
term.ClearAll()
util.LogPad("Updated %s to %s", version, r.Version)
return nil
} | go | func Upgrade(version string) error {
term.HideCursor()
defer term.ShowCursor()
p := &update.Manager{
Command: "apex",
Store: &github.Store{
Owner: "apex",
Repo: "apex",
Version: version,
},
}
// fetch releases
releases, err := p.LatestReleases()
if err != nil {
return errors.Wrap(err, "fetching latest release")
}
// no updates
if len(releases) == 0 {
util.LogPad("No updates available, you're good :)")
return nil
}
// latest
r := releases[0]
// find the tarball for this system
a := r.FindTarball(runtime.GOOS, runtime.GOARCH)
if a == nil {
return errors.Errorf("failed to find a binary for %s %s", runtime.GOOS, runtime.GOARCH)
}
// download tarball to a tmp dir
tarball, err := a.DownloadProxy(progressreader.New)
if err != nil {
return errors.Wrap(err, "downloading tarball")
}
// install it
if err := p.Install(tarball); err != nil {
return errors.Wrap(err, "installing")
}
term.ClearAll()
util.LogPad("Updated %s to %s", version, r.Version)
return nil
} | [
"func",
"Upgrade",
"(",
"version",
"string",
")",
"error",
"{",
"term",
".",
"HideCursor",
"(",
")",
"\n",
"defer",
"term",
".",
"ShowCursor",
"(",
")",
"\n\n",
"p",
":=",
"&",
"update",
".",
"Manager",
"{",
"Command",
":",
"\"",
"\"",
",",
"Store",
":",
"&",
"github",
".",
"Store",
"{",
"Owner",
":",
"\"",
"\"",
",",
"Repo",
":",
"\"",
"\"",
",",
"Version",
":",
"version",
",",
"}",
",",
"}",
"\n\n",
"// fetch releases",
"releases",
",",
"err",
":=",
"p",
".",
"LatestReleases",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// no updates",
"if",
"len",
"(",
"releases",
")",
"==",
"0",
"{",
"util",
".",
"LogPad",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"// latest",
"r",
":=",
"releases",
"[",
"0",
"]",
"\n\n",
"// find the tarball for this system",
"a",
":=",
"r",
".",
"FindTarball",
"(",
"runtime",
".",
"GOOS",
",",
"runtime",
".",
"GOARCH",
")",
"\n",
"if",
"a",
"==",
"nil",
"{",
"return",
"errors",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"runtime",
".",
"GOOS",
",",
"runtime",
".",
"GOARCH",
")",
"\n",
"}",
"\n\n",
"// download tarball to a tmp dir",
"tarball",
",",
"err",
":=",
"a",
".",
"DownloadProxy",
"(",
"progressreader",
".",
"New",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// install it",
"if",
"err",
":=",
"p",
".",
"Install",
"(",
"tarball",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"errors",
".",
"Wrap",
"(",
"err",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"term",
".",
"ClearAll",
"(",
")",
"\n",
"util",
".",
"LogPad",
"(",
"\"",
"\"",
",",
"version",
",",
"r",
".",
"Version",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Upgrade the current `version` of apex to the latest. | [
"Upgrade",
"the",
"current",
"version",
"of",
"apex",
"to",
"the",
"latest",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/upgrade/upgrade.go#L17-L66 | train |
apex/apex | boot/boot.go | Boot | func (b *Bootstrapper) Boot() error {
fmt.Println(logo)
if b.isProject() {
help("I've detected a ./project.json file, this seems to already be a project!")
return nil
}
help("Enter the name of your project. It should be machine-friendly, as this\nis used to prefix your functions in Lambda.")
b.name = prompt.StringRequired(indent(" Project name: "))
help("Enter an optional description of your project.")
b.description = prompt.String(indent(" Project description: "))
fmt.Println()
return b.bootVanilla()
} | go | func (b *Bootstrapper) Boot() error {
fmt.Println(logo)
if b.isProject() {
help("I've detected a ./project.json file, this seems to already be a project!")
return nil
}
help("Enter the name of your project. It should be machine-friendly, as this\nis used to prefix your functions in Lambda.")
b.name = prompt.StringRequired(indent(" Project name: "))
help("Enter an optional description of your project.")
b.description = prompt.String(indent(" Project description: "))
fmt.Println()
return b.bootVanilla()
} | [
"func",
"(",
"b",
"*",
"Bootstrapper",
")",
"Boot",
"(",
")",
"error",
"{",
"fmt",
".",
"Println",
"(",
"logo",
")",
"\n\n",
"if",
"b",
".",
"isProject",
"(",
")",
"{",
"help",
"(",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"help",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"b",
".",
"name",
"=",
"prompt",
".",
"StringRequired",
"(",
"indent",
"(",
"\"",
"\"",
")",
")",
"\n\n",
"help",
"(",
"\"",
"\"",
")",
"\n",
"b",
".",
"description",
"=",
"prompt",
".",
"String",
"(",
"indent",
"(",
"\"",
"\"",
")",
")",
"\n\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"return",
"b",
".",
"bootVanilla",
"(",
")",
"\n",
"}"
] | // Boot the project. | [
"Boot",
"the",
"project",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L82-L98 | train |
apex/apex | boot/boot.go | isProject | func (b *Bootstrapper) isProject() bool {
_, err := os.Stat("project.json")
return err == nil
} | go | func (b *Bootstrapper) isProject() bool {
_, err := os.Stat("project.json")
return err == nil
} | [
"func",
"(",
"b",
"*",
"Bootstrapper",
")",
"isProject",
"(",
")",
"bool",
"{",
"_",
",",
"err",
":=",
"os",
".",
"Stat",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err",
"==",
"nil",
"\n",
"}"
] | // check if there's a project. | [
"check",
"if",
"there",
"s",
"a",
"project",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L101-L104 | train |
apex/apex | boot/boot.go | bootVanilla | func (b *Bootstrapper) bootVanilla() error {
iamRole, err := b.createRole()
if err != nil {
return err
}
if err := b.initProjectFiles(iamRole); err != nil {
return err
}
fmt.Println(setupCompleteVanilla)
return nil
} | go | func (b *Bootstrapper) bootVanilla() error {
iamRole, err := b.createRole()
if err != nil {
return err
}
if err := b.initProjectFiles(iamRole); err != nil {
return err
}
fmt.Println(setupCompleteVanilla)
return nil
} | [
"func",
"(",
"b",
"*",
"Bootstrapper",
")",
"bootVanilla",
"(",
")",
"error",
"{",
"iamRole",
",",
"err",
":=",
"b",
".",
"createRole",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"b",
".",
"initProjectFiles",
"(",
"iamRole",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Println",
"(",
"setupCompleteVanilla",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Bootstrap without Terraform. | [
"Bootstrap",
"without",
"Terraform",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L107-L119 | train |
apex/apex | boot/boot.go | createRole | func (b *Bootstrapper) createRole() (string, error) {
roleName := fmt.Sprintf("%s_lambda_function", b.name)
policyName := fmt.Sprintf("%s_lambda_logs", b.name)
logf("creating IAM %s role", roleName)
role, err := b.IAM.CreateRole(&iam.CreateRoleInput{
RoleName: &roleName,
AssumeRolePolicyDocument: aws.String(iamAssumeRolePolicy),
})
if err != nil {
return "", fmt.Errorf("creating role: %s", err)
}
logf("creating IAM %s policy", policyName)
policy, err := b.IAM.CreatePolicy(&iam.CreatePolicyInput{
PolicyName: &policyName,
Description: aws.String("Allow lambda_function to utilize CloudWatchLogs. Created by apex(1)."),
PolicyDocument: aws.String(iamLogsPolicy),
})
if err != nil {
return "", fmt.Errorf("creating policy: %s", err)
}
logf("attaching policy to lambda_function role.")
_, err = b.IAM.AttachRolePolicy(&iam.AttachRolePolicyInput{
RoleName: &roleName,
PolicyArn: policy.Policy.Arn,
})
if err != nil {
return "", fmt.Errorf("creating policy: %s", err)
}
return *role.Role.Arn, nil
} | go | func (b *Bootstrapper) createRole() (string, error) {
roleName := fmt.Sprintf("%s_lambda_function", b.name)
policyName := fmt.Sprintf("%s_lambda_logs", b.name)
logf("creating IAM %s role", roleName)
role, err := b.IAM.CreateRole(&iam.CreateRoleInput{
RoleName: &roleName,
AssumeRolePolicyDocument: aws.String(iamAssumeRolePolicy),
})
if err != nil {
return "", fmt.Errorf("creating role: %s", err)
}
logf("creating IAM %s policy", policyName)
policy, err := b.IAM.CreatePolicy(&iam.CreatePolicyInput{
PolicyName: &policyName,
Description: aws.String("Allow lambda_function to utilize CloudWatchLogs. Created by apex(1)."),
PolicyDocument: aws.String(iamLogsPolicy),
})
if err != nil {
return "", fmt.Errorf("creating policy: %s", err)
}
logf("attaching policy to lambda_function role.")
_, err = b.IAM.AttachRolePolicy(&iam.AttachRolePolicyInput{
RoleName: &roleName,
PolicyArn: policy.Policy.Arn,
})
if err != nil {
return "", fmt.Errorf("creating policy: %s", err)
}
return *role.Role.Arn, nil
} | [
"func",
"(",
"b",
"*",
"Bootstrapper",
")",
"createRole",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"roleName",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
".",
"name",
")",
"\n",
"policyName",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
".",
"name",
")",
"\n\n",
"logf",
"(",
"\"",
"\"",
",",
"roleName",
")",
"\n",
"role",
",",
"err",
":=",
"b",
".",
"IAM",
".",
"CreateRole",
"(",
"&",
"iam",
".",
"CreateRoleInput",
"{",
"RoleName",
":",
"&",
"roleName",
",",
"AssumeRolePolicyDocument",
":",
"aws",
".",
"String",
"(",
"iamAssumeRolePolicy",
")",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logf",
"(",
"\"",
"\"",
",",
"policyName",
")",
"\n",
"policy",
",",
"err",
":=",
"b",
".",
"IAM",
".",
"CreatePolicy",
"(",
"&",
"iam",
".",
"CreatePolicyInput",
"{",
"PolicyName",
":",
"&",
"policyName",
",",
"Description",
":",
"aws",
".",
"String",
"(",
"\"",
"\"",
")",
",",
"PolicyDocument",
":",
"aws",
".",
"String",
"(",
"iamLogsPolicy",
")",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"logf",
"(",
"\"",
"\"",
")",
"\n",
"_",
",",
"err",
"=",
"b",
".",
"IAM",
".",
"AttachRolePolicy",
"(",
"&",
"iam",
".",
"AttachRolePolicyInput",
"{",
"RoleName",
":",
"&",
"roleName",
",",
"PolicyArn",
":",
"policy",
".",
"Policy",
".",
"Arn",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"*",
"role",
".",
"Role",
".",
"Arn",
",",
"nil",
"\n",
"}"
] | // Create IAM role, returning the ARN. | [
"Create",
"IAM",
"role",
"returning",
"the",
"ARN",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L122-L158 | train |
apex/apex | boot/boot.go | help | func help(s string) {
os.Stdout.WriteString("\n")
os.Stdout.WriteString(indent(s))
os.Stdout.WriteString("\n\n")
} | go | func help(s string) {
os.Stdout.WriteString("\n")
os.Stdout.WriteString(indent(s))
os.Stdout.WriteString("\n\n")
} | [
"func",
"help",
"(",
"s",
"string",
")",
"{",
"os",
".",
"Stdout",
".",
"WriteString",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"os",
".",
"Stdout",
".",
"WriteString",
"(",
"indent",
"(",
"s",
")",
")",
"\n",
"os",
".",
"Stdout",
".",
"WriteString",
"(",
"\"",
"\\n",
"\\n",
"\"",
")",
"\n",
"}"
] | // help string output. | [
"help",
"string",
"output",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L175-L179 | train |
apex/apex | boot/boot.go | indent | func indent(s string) (out string) {
for _, l := range strings.SplitAfter(s, "\n") {
out += fmt.Sprintf(" %s", l)
}
return
} | go | func indent(s string) (out string) {
for _, l := range strings.SplitAfter(s, "\n") {
out += fmt.Sprintf(" %s", l)
}
return
} | [
"func",
"indent",
"(",
"s",
"string",
")",
"(",
"out",
"string",
")",
"{",
"for",
"_",
",",
"l",
":=",
"range",
"strings",
".",
"SplitAfter",
"(",
"s",
",",
"\"",
"\\n",
"\"",
")",
"{",
"out",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"l",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // indent multiline string with 2 spaces. | [
"indent",
"multiline",
"string",
"with",
"2",
"spaces",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L182-L188 | train |
apex/apex | boot/boot.go | logf | func logf(s string, v ...interface{}) {
fmt.Printf(" \033[34m[+]\033[0m %s\n", fmt.Sprintf(s, v...))
} | go | func logf(s string, v ...interface{}) {
fmt.Printf(" \033[34m[+]\033[0m %s\n", fmt.Sprintf(s, v...))
} | [
"func",
"logf",
"(",
"s",
"string",
",",
"v",
"...",
"interface",
"{",
"}",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\033",
"\\033",
"\\n",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"s",
",",
"v",
"...",
")",
")",
"\n",
"}"
] | // logf outputs a log message. | [
"logf",
"outputs",
"a",
"log",
"message",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/boot/boot.go#L191-L193 | train |
apex/apex | logs/logs.go | wait | func (l *Logs) wait(done <-chan error) {
for range l.GroupNames {
if err := <-done; err != nil {
l.err = err
return
}
}
} | go | func (l *Logs) wait(done <-chan error) {
for range l.GroupNames {
if err := <-done; err != nil {
l.err = err
return
}
}
} | [
"func",
"(",
"l",
"*",
"Logs",
")",
"wait",
"(",
"done",
"<-",
"chan",
"error",
")",
"{",
"for",
"range",
"l",
".",
"GroupNames",
"{",
"if",
"err",
":=",
"<-",
"done",
";",
"err",
"!=",
"nil",
"{",
"l",
".",
"err",
"=",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // wait for each log group to complete. | [
"wait",
"for",
"each",
"log",
"group",
"to",
"complete",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/logs/logs.go#L56-L63 | train |
apex/apex | logs/logs.go | consume | func (l *Logs) consume(name string, ch chan *Event, done chan error) {
log := Log{
Config: l.Config,
GroupName: name,
Log: log.WithField("group", name),
}
for event := range log.Start() {
ch <- event
}
done <- log.Err()
} | go | func (l *Logs) consume(name string, ch chan *Event, done chan error) {
log := Log{
Config: l.Config,
GroupName: name,
Log: log.WithField("group", name),
}
for event := range log.Start() {
ch <- event
}
done <- log.Err()
} | [
"func",
"(",
"l",
"*",
"Logs",
")",
"consume",
"(",
"name",
"string",
",",
"ch",
"chan",
"*",
"Event",
",",
"done",
"chan",
"error",
")",
"{",
"log",
":=",
"Log",
"{",
"Config",
":",
"l",
".",
"Config",
",",
"GroupName",
":",
"name",
",",
"Log",
":",
"log",
".",
"WithField",
"(",
"\"",
"\"",
",",
"name",
")",
",",
"}",
"\n\n",
"for",
"event",
":=",
"range",
"log",
".",
"Start",
"(",
")",
"{",
"ch",
"<-",
"event",
"\n",
"}",
"\n\n",
"done",
"<-",
"log",
".",
"Err",
"(",
")",
"\n",
"}"
] | // consume logs for group `name`. | [
"consume",
"logs",
"for",
"group",
"name",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/logs/logs.go#L66-L78 | train |
apex/apex | cmd/apex/root/root.go | preRun | func preRun(c *cobra.Command, args []string) error {
err := Prepare(c, args)
if err != nil {
return err
}
return Project.Open()
} | go | func preRun(c *cobra.Command, args []string) error {
err := Prepare(c, args)
if err != nil {
return err
}
return Project.Open()
} | [
"func",
"preRun",
"(",
"c",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"err",
":=",
"Prepare",
"(",
"c",
",",
"args",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"Project",
".",
"Open",
"(",
")",
"\n",
"}"
] | // preRun sets up global tasks used for most commands, some use PreRunNoop
// to remove this default behaviour. | [
"preRun",
"sets",
"up",
"global",
"tasks",
"used",
"for",
"most",
"commands",
"some",
"use",
"PreRunNoop",
"to",
"remove",
"this",
"default",
"behaviour",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/cmd/apex/root/root.go#L84-L91 | train |
apex/apex | utils/utils.go | Sha256 | func Sha256(b []byte) string {
h := sha256.New()
h.Write(b)
return base64.StdEncoding.EncodeToString(h.Sum(nil))
} | go | func Sha256(b []byte) string {
h := sha256.New()
h.Write(b)
return base64.StdEncoding.EncodeToString(h.Sum(nil))
} | [
"func",
"Sha256",
"(",
"b",
"[",
"]",
"byte",
")",
"string",
"{",
"h",
":=",
"sha256",
".",
"New",
"(",
")",
"\n",
"h",
".",
"Write",
"(",
"b",
")",
"\n",
"return",
"base64",
".",
"StdEncoding",
".",
"EncodeToString",
"(",
"h",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"}"
] | // Sha256 returns a base64 encoded SHA256 hash of `b`. | [
"Sha256",
"returns",
"a",
"base64",
"encoded",
"SHA256",
"hash",
"of",
"b",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L24-L28 | train |
apex/apex | utils/utils.go | LoadFiles | func LoadFiles(root string, ignoreFile []byte) (files []string, err error) {
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
mode := info.Mode()
if !(mode.IsDir() || mode.IsRegular() || mode&os.ModeSymlink == os.ModeSymlink) {
return nil
}
rel, err := filepath.Rel(root, path)
if err != nil {
return err
}
matched, err := gitignorer.GitIgnore(bytes.NewReader(ignoreFile), rel)
if err != nil {
return err
}
if mode.IsDir() && matched {
return filepath.SkipDir
} else if mode.IsDir() || matched {
return nil
}
files = append(files, rel)
return nil
})
return
} | go | func LoadFiles(root string, ignoreFile []byte) (files []string, err error) {
err = filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
mode := info.Mode()
if !(mode.IsDir() || mode.IsRegular() || mode&os.ModeSymlink == os.ModeSymlink) {
return nil
}
rel, err := filepath.Rel(root, path)
if err != nil {
return err
}
matched, err := gitignorer.GitIgnore(bytes.NewReader(ignoreFile), rel)
if err != nil {
return err
}
if mode.IsDir() && matched {
return filepath.SkipDir
} else if mode.IsDir() || matched {
return nil
}
files = append(files, rel)
return nil
})
return
} | [
"func",
"LoadFiles",
"(",
"root",
"string",
",",
"ignoreFile",
"[",
"]",
"byte",
")",
"(",
"files",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"err",
"=",
"filepath",
".",
"Walk",
"(",
"root",
",",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"mode",
":=",
"info",
".",
"Mode",
"(",
")",
"\n",
"if",
"!",
"(",
"mode",
".",
"IsDir",
"(",
")",
"||",
"mode",
".",
"IsRegular",
"(",
")",
"||",
"mode",
"&",
"os",
".",
"ModeSymlink",
"==",
"os",
".",
"ModeSymlink",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"rel",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"root",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"matched",
",",
"err",
":=",
"gitignorer",
".",
"GitIgnore",
"(",
"bytes",
".",
"NewReader",
"(",
"ignoreFile",
")",
",",
"rel",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"mode",
".",
"IsDir",
"(",
")",
"&&",
"matched",
"{",
"return",
"filepath",
".",
"SkipDir",
"\n",
"}",
"else",
"if",
"mode",
".",
"IsDir",
"(",
")",
"||",
"matched",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"files",
"=",
"append",
"(",
"files",
",",
"rel",
")",
"\n\n",
"return",
"nil",
"\n",
"}",
")",
"\n\n",
"return",
"\n",
"}"
] | // LoadFiles return filtered map of relative to 'root' file paths;
// for filtering it uses shell file name pattern matching | [
"LoadFiles",
"return",
"filtered",
"map",
"of",
"relative",
"to",
"root",
"file",
"paths",
";",
"for",
"filtering",
"it",
"uses",
"shell",
"file",
"name",
"pattern",
"matching"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L32-L65 | train |
apex/apex | utils/utils.go | ReadIgnoreFile | func ReadIgnoreFile(dir string) ([]byte, error) {
path := filepath.Join(dir, ".apexignore")
b, err := ioutil.ReadFile(path)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
return b, nil
} | go | func ReadIgnoreFile(dir string) ([]byte, error) {
path := filepath.Join(dir, ".apexignore")
b, err := ioutil.ReadFile(path)
if os.IsNotExist(err) {
return nil, nil
}
if err != nil {
return nil, err
}
return b, nil
} | [
"func",
"ReadIgnoreFile",
"(",
"dir",
"string",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"path",
":=",
"filepath",
".",
"Join",
"(",
"dir",
",",
"\"",
"\"",
")",
"\n\n",
"b",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"path",
")",
"\n\n",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] | // ReadIgnoreFile reads .apexignore in `dir` when present and returns a list of patterns. | [
"ReadIgnoreFile",
"reads",
".",
"apexignore",
"in",
"dir",
"when",
"present",
"and",
"returns",
"a",
"list",
"of",
"patterns",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L94-L108 | train |
apex/apex | utils/utils.go | ContainsString | func ContainsString(array []string, element string) bool {
for _, e := range array {
if element == e {
return true
}
}
return false
} | go | func ContainsString(array []string, element string) bool {
for _, e := range array {
if element == e {
return true
}
}
return false
} | [
"func",
"ContainsString",
"(",
"array",
"[",
"]",
"string",
",",
"element",
"string",
")",
"bool",
"{",
"for",
"_",
",",
"e",
":=",
"range",
"array",
"{",
"if",
"element",
"==",
"e",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // ContainsString checks if array contains string | [
"ContainsString",
"checks",
"if",
"array",
"contains",
"string"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L111-L118 | train |
apex/apex | utils/utils.go | ParseEnv | func ParseEnv(env []string) (map[string]string, error) {
m := make(map[string]string)
for _, s := range env {
parts := strings.SplitN(s, "=", 2)
if len(parts) == 2 {
m[parts[0]] = parts[1]
} else {
return nil, fmt.Errorf("environment variable %q is missing a value", parts[0])
}
}
return m, nil
} | go | func ParseEnv(env []string) (map[string]string, error) {
m := make(map[string]string)
for _, s := range env {
parts := strings.SplitN(s, "=", 2)
if len(parts) == 2 {
m[parts[0]] = parts[1]
} else {
return nil, fmt.Errorf("environment variable %q is missing a value", parts[0])
}
}
return m, nil
} | [
"func",
"ParseEnv",
"(",
"env",
"[",
"]",
"string",
")",
"(",
"map",
"[",
"string",
"]",
"string",
",",
"error",
")",
"{",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
"\n\n",
"for",
"_",
",",
"s",
":=",
"range",
"env",
"{",
"parts",
":=",
"strings",
".",
"SplitN",
"(",
"s",
",",
"\"",
"\"",
",",
"2",
")",
"\n",
"if",
"len",
"(",
"parts",
")",
"==",
"2",
"{",
"m",
"[",
"parts",
"[",
"0",
"]",
"]",
"=",
"parts",
"[",
"1",
"]",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"parts",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] | // ParseEnv accepts an `env` slice from the command-line and returns a map. | [
"ParseEnv",
"accepts",
"an",
"env",
"slice",
"from",
"the",
"command",
"-",
"line",
"and",
"returns",
"a",
"map",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L121-L134 | train |
apex/apex | utils/utils.go | ProfileAndRegionFromConfig | func ProfileAndRegionFromConfig(environment string) (string, string, error) {
configFile := "project.json"
if environment != "" {
configFile = fmt.Sprintf("project.%s.json", environment)
}
f, err := os.Open(configFile)
if err != nil {
return "", "", err
}
defer f.Close()
var v struct {
Profile string `json:"profile"`
Region string `json:"region"`
}
if err := json.NewDecoder(f).Decode(&v); err != nil {
return "", "", err
}
return v.Profile, v.Region, nil
} | go | func ProfileAndRegionFromConfig(environment string) (string, string, error) {
configFile := "project.json"
if environment != "" {
configFile = fmt.Sprintf("project.%s.json", environment)
}
f, err := os.Open(configFile)
if err != nil {
return "", "", err
}
defer f.Close()
var v struct {
Profile string `json:"profile"`
Region string `json:"region"`
}
if err := json.NewDecoder(f).Decode(&v); err != nil {
return "", "", err
}
return v.Profile, v.Region, nil
} | [
"func",
"ProfileAndRegionFromConfig",
"(",
"environment",
"string",
")",
"(",
"string",
",",
"string",
",",
"error",
")",
"{",
"configFile",
":=",
"\"",
"\"",
"\n\n",
"if",
"environment",
"!=",
"\"",
"\"",
"{",
"configFile",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"environment",
")",
"\n",
"}",
"\n\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"configFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n\n",
"var",
"v",
"struct",
"{",
"Profile",
"string",
"`json:\"profile\"`",
"\n",
"Region",
"string",
"`json:\"region\"`",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"f",
")",
".",
"Decode",
"(",
"&",
"v",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"v",
".",
"Profile",
",",
"v",
".",
"Region",
",",
"nil",
"\n",
"}"
] | // ProfileAndRegionFromConfig attempts to load the .profile setting from `environment`'s config. | [
"ProfileAndRegionFromConfig",
"attempts",
"to",
"load",
"the",
".",
"profile",
"setting",
"from",
"environment",
"s",
"config",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/utils/utils.go#L137-L160 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.