repo stringlengths 5 67 | path stringlengths 4 218 | func_name stringlengths 0 151 | original_string stringlengths 52 373k | language stringclasses 6 values | code stringlengths 52 373k | code_tokens listlengths 10 512 | docstring stringlengths 3 47.2k | docstring_tokens listlengths 3 234 | sha stringlengths 40 40 | url stringlengths 85 339 | partition stringclasses 3 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
apex/apex | cmd/apex/invoke/invoke.go | input | func input() io.Reader {
if isatty.IsTerminal(os.Stdin.Fd()) {
return strings.NewReader("{}")
}
return os.Stdin
} | go | func input() io.Reader {
if isatty.IsTerminal(os.Stdin.Fd()) {
return strings.NewReader("{}")
}
return os.Stdin
} | [
"func",
"input",
"(",
")",
"io",
".",
"Reader",
"{",
"if",
"isatty",
".",
"IsTerminal",
"(",
"os",
".",
"Stdin",
".",
"Fd",
"(",
")",
")",
"{",
"return",
"strings",
".",
"NewReader",
"(",
"\"{}\"",
")",
"\n",
"}",
"\n",
"return",
"os",
".",
"Stdin",
"\n",
"}"
] | // input from stdin or empty object by default. | [
"input",
"from",
"stdin",
"or",
"empty",
"object",
"by",
"default",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/cmd/apex/invoke/invoke.go#L111-L117 | train |
apex/apex | infra/infra.go | Run | func (p *Proxy) Run(args ...string) error {
if p.shouldInjectVars(args) {
args = append(args, p.functionVars()...)
}
log.WithFields(log.Fields{
"args": args,
}).Debug("terraform")
cmd := exec.Command("terraform", args...)
cmd.Env = append(os.Environ(), fmt.Sprintf("AWS_REGION=%s", p.Region))
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = filepath.Join(Dir, p.Environment)
return cmd.Run()
} | go | func (p *Proxy) Run(args ...string) error {
if p.shouldInjectVars(args) {
args = append(args, p.functionVars()...)
}
log.WithFields(log.Fields{
"args": args,
}).Debug("terraform")
cmd := exec.Command("terraform", args...)
cmd.Env = append(os.Environ(), fmt.Sprintf("AWS_REGION=%s", p.Region))
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
cmd.Dir = filepath.Join(Dir, p.Environment)
return cmd.Run()
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"Run",
"(",
"args",
"...",
"string",
")",
"error",
"{",
"if",
"p",
".",
"shouldInjectVars",
"(",
"args",
")",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"p",
".",
"functionVars",
"(",
")",
"...",
")",
"\n",
"}",
"\n",
"log",
".",
"WithFields",
"(",
"log",
".",
"Fields",
"{",
"\"args\"",
":",
"args",
",",
"}",
")",
".",
"Debug",
"(",
"\"terraform\"",
")",
"\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"terraform\"",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Env",
"=",
"append",
"(",
"os",
".",
"Environ",
"(",
")",
",",
"fmt",
".",
"Sprintf",
"(",
"\"AWS_REGION=%s\"",
",",
"p",
".",
"Region",
")",
")",
"\n",
"cmd",
".",
"Stdin",
"=",
"os",
".",
"Stdin",
"\n",
"cmd",
".",
"Stdout",
"=",
"os",
".",
"Stdout",
"\n",
"cmd",
".",
"Stderr",
"=",
"os",
".",
"Stderr",
"\n",
"cmd",
".",
"Dir",
"=",
"filepath",
".",
"Join",
"(",
"Dir",
",",
"p",
".",
"Environment",
")",
"\n",
"return",
"cmd",
".",
"Run",
"(",
")",
"\n",
"}"
] | // Run terraform command in infrastructure directory. | [
"Run",
"terraform",
"command",
"in",
"infrastructure",
"directory",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L29-L46 | train |
apex/apex | infra/infra.go | shouldInjectVars | func (p *Proxy) shouldInjectVars(args []string) bool {
if len(args) == 0 {
return false
}
return args[0] == "plan" || args[0] == "apply" || args[0] == "destroy" || args[0] == "refresh"
} | go | func (p *Proxy) shouldInjectVars(args []string) bool {
if len(args) == 0 {
return false
}
return args[0] == "plan" || args[0] == "apply" || args[0] == "destroy" || args[0] == "refresh"
} | [
"func",
"(",
"p",
"*",
"Proxy",
")",
"shouldInjectVars",
"(",
"args",
"[",
"]",
"string",
")",
"bool",
"{",
"if",
"len",
"(",
"args",
")",
"==",
"0",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"args",
"[",
"0",
"]",
"==",
"\"plan\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"apply\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"destroy\"",
"||",
"args",
"[",
"0",
"]",
"==",
"\"refresh\"",
"\n",
"}"
] | // shouldInjectVars checks if the command accepts -var flags. | [
"shouldInjectVars",
"checks",
"if",
"the",
"command",
"accepts",
"-",
"var",
"flags",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L49-L55 | train |
apex/apex | infra/infra.go | Output | func Output(environment, name string) (string, error) {
cmd := exec.Command("sh", "-c", fmt.Sprintf("terraform output %s", name))
cmd.Dir = filepath.Join(Dir, environment)
out, err := cmd.CombinedOutput()
if err != nil {
return "", err
}
return strings.Trim(string(out), "\n"), nil
} | go | func Output(environment, name string) (string, error) {
cmd := exec.Command("sh", "-c", fmt.Sprintf("terraform output %s", name))
cmd.Dir = filepath.Join(Dir, environment)
out, err := cmd.CombinedOutput()
if err != nil {
return "", err
}
return strings.Trim(string(out), "\n"), nil
} | [
"func",
"Output",
"(",
"environment",
",",
"name",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"sh\"",
",",
"\"-c\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"terraform output %s\"",
",",
"name",
")",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"filepath",
".",
"Join",
"(",
"Dir",
",",
"environment",
")",
"\n",
"out",
",",
"err",
":=",
"cmd",
".",
"CombinedOutput",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Trim",
"(",
"string",
"(",
"out",
")",
",",
"\"\\n\"",
")",
",",
"nil",
"\n",
"}"
] | // Output fetches output variable `name` from terraform. | [
"Output",
"fetches",
"output",
"variable",
"name",
"from",
"terraform",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/infra/infra.go#L58-L68 | train |
apex/apex | archive/zip.go | AddBytes | func (z *Zip) AddBytes(path string, contents []byte) error {
z.lock.Lock()
defer z.lock.Unlock()
header := &zip.FileHeader{
Name: path,
Method: zip.Deflate,
}
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = zippedFile.Write(contents)
return err
} | go | func (z *Zip) AddBytes(path string, contents []byte) error {
z.lock.Lock()
defer z.lock.Unlock()
header := &zip.FileHeader{
Name: path,
Method: zip.Deflate,
}
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = zippedFile.Write(contents)
return err
} | [
"func",
"(",
"z",
"*",
"Zip",
")",
"AddBytes",
"(",
"path",
"string",
",",
"contents",
"[",
"]",
"byte",
")",
"error",
"{",
"z",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"z",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"header",
":=",
"&",
"zip",
".",
"FileHeader",
"{",
"Name",
":",
"path",
",",
"Method",
":",
"zip",
".",
"Deflate",
",",
"}",
"\n",
"header",
".",
"SetModTime",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
")",
"\n",
"zippedFile",
",",
"err",
":=",
"z",
".",
"writer",
".",
"CreateHeader",
"(",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"zippedFile",
".",
"Write",
"(",
"contents",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // AddBytes add bytes to archive. | [
"AddBytes",
"add",
"bytes",
"to",
"archive",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L33-L51 | train |
apex/apex | archive/zip.go | AddFile | func (z *Zip) AddFile(path string, file *os.File) error {
path = strings.Replace(path, "\\", "/", -1)
z.lock.Lock()
defer z.lock.Unlock()
info, err := file.Stat()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return errors.New("Only regular files supported: " + path)
}
header, err := zip.FileInfoHeader(info)
if err != nil {
return err
}
header.Name = path
header.Method = zip.Deflate
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = io.Copy(zippedFile, file)
return err
} | go | func (z *Zip) AddFile(path string, file *os.File) error {
path = strings.Replace(path, "\\", "/", -1)
z.lock.Lock()
defer z.lock.Unlock()
info, err := file.Stat()
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return errors.New("Only regular files supported: " + path)
}
header, err := zip.FileInfoHeader(info)
if err != nil {
return err
}
header.Name = path
header.Method = zip.Deflate
header.SetModTime(time.Unix(0, 0))
zippedFile, err := z.writer.CreateHeader(header)
if err != nil {
return err
}
_, err = io.Copy(zippedFile, file)
return err
} | [
"func",
"(",
"z",
"*",
"Zip",
")",
"AddFile",
"(",
"path",
"string",
",",
"file",
"*",
"os",
".",
"File",
")",
"error",
"{",
"path",
"=",
"strings",
".",
"Replace",
"(",
"path",
",",
"\"\\\\\"",
",",
"\\\\",
",",
"\"/\"",
")",
"\n",
"-",
"1",
"\n",
"z",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"z",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"info",
",",
"err",
":=",
"file",
".",
"Stat",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"info",
".",
"Mode",
"(",
")",
".",
"IsRegular",
"(",
")",
"{",
"return",
"errors",
".",
"New",
"(",
"\"Only regular files supported: \"",
"+",
"path",
")",
"\n",
"}",
"\n",
"header",
",",
"err",
":=",
"zip",
".",
"FileInfoHeader",
"(",
"info",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"header",
".",
"Name",
"=",
"path",
"\n",
"header",
".",
"Method",
"=",
"zip",
".",
"Deflate",
"\n",
"header",
".",
"SetModTime",
"(",
"time",
".",
"Unix",
"(",
"0",
",",
"0",
")",
")",
"\n",
"zippedFile",
",",
"err",
":=",
"z",
".",
"writer",
".",
"CreateHeader",
"(",
"header",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"Copy",
"(",
"zippedFile",
",",
"file",
")",
"\n",
"}"
] | // AddFile adds a file to archive.
// AddFile resets mtime. | [
"AddFile",
"adds",
"a",
"file",
"to",
"archive",
".",
"AddFile",
"resets",
"mtime",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L55-L85 | train |
apex/apex | archive/zip.go | AddDir | func (z *Zip) AddDir(root, target string) error {
return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return nil
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
rel, err := filepath.Rel(root, path)
if err != nil {
return err
}
archivePath := filepath.Join(target, rel)
return z.AddFile(archivePath, file)
})
} | go | func (z *Zip) AddDir(root, target string) error {
return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if !info.Mode().IsRegular() {
return nil
}
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
rel, err := filepath.Rel(root, path)
if err != nil {
return err
}
archivePath := filepath.Join(target, rel)
return z.AddFile(archivePath, file)
})
} | [
"func",
"(",
"z",
"*",
"Zip",
")",
"AddDir",
"(",
"root",
",",
"target",
"string",
")",
"error",
"{",
"return",
"filepath",
".",
"Walk",
"(",
"root",
",",
"func",
"(",
"path",
"string",
",",
"info",
"os",
".",
"FileInfo",
",",
"err",
"error",
")",
"error",
"{",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"!",
"info",
".",
"Mode",
"(",
")",
".",
"IsRegular",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"defer",
"file",
".",
"Close",
"(",
")",
"\n",
"rel",
",",
"err",
":=",
"filepath",
".",
"Rel",
"(",
"root",
",",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"archivePath",
":=",
"filepath",
".",
"Join",
"(",
"target",
",",
"rel",
")",
"\n",
"return",
"z",
".",
"AddFile",
"(",
"archivePath",
",",
"file",
")",
"\n",
"}",
")",
"\n",
"}"
] | // AddDir to target path in archive. This function doesn't follow symlinks. | [
"AddDir",
"to",
"target",
"path",
"in",
"archive",
".",
"This",
"function",
"doesn",
"t",
"follow",
"symlinks",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/archive/zip.go#L88-L112 | train |
apex/apex | dryrun/dryrun.go | New | func New(session *session.Session) *Lambda {
fmt.Printf("\n")
return &Lambda{
Lambda: lambda.New(session),
}
} | go | func New(session *session.Session) *Lambda {
fmt.Printf("\n")
return &Lambda{
Lambda: lambda.New(session),
}
} | [
"func",
"New",
"(",
"session",
"*",
"session",
".",
"Session",
")",
"*",
"Lambda",
"{",
"fmt",
".",
"Printf",
"(",
"\"\\n\"",
")",
"\n",
"\\n",
"\n",
"}"
] | // New dry-run Lambda service for the given session. | [
"New",
"dry",
"-",
"run",
"Lambda",
"service",
"for",
"the",
"given",
"session",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L29-L34 | train |
apex/apex | dryrun/dryrun.go | CreateFunction | func (l *Lambda) CreateFunction(in *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
l.create("function", *in.FunctionName, map[string]interface{}{
"runtime": *in.Runtime,
"memory": *in.MemorySize,
"timeout": *in.Timeout,
"handler": *in.Handler,
})
out := &lambda.FunctionConfiguration{
Version: aws.String("1"),
}
return out, nil
} | go | func (l *Lambda) CreateFunction(in *lambda.CreateFunctionInput) (*lambda.FunctionConfiguration, error) {
l.create("function", *in.FunctionName, map[string]interface{}{
"runtime": *in.Runtime,
"memory": *in.MemorySize,
"timeout": *in.Timeout,
"handler": *in.Handler,
})
out := &lambda.FunctionConfiguration{
Version: aws.String("1"),
}
return out, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"CreateFunction",
"(",
"in",
"*",
"lambda",
".",
"CreateFunctionInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"l",
".",
"create",
"(",
"\"function\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"runtime\"",
":",
"*",
"in",
".",
"Runtime",
",",
"\"memory\"",
":",
"*",
"in",
".",
"MemorySize",
",",
"\"timeout\"",
":",
"*",
"in",
".",
"Timeout",
",",
"\"handler\"",
":",
"*",
"in",
".",
"Handler",
",",
"}",
")",
"\n",
"out",
":=",
"&",
"lambda",
".",
"FunctionConfiguration",
"{",
"Version",
":",
"aws",
".",
"String",
"(",
"\"1\"",
")",
",",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // CreateFunction stub. | [
"CreateFunction",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L37-L50 | train |
apex/apex | dryrun/dryrun.go | UpdateFunctionCode | func (l *Lambda) UpdateFunctionCode(in *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunction(&lambda.GetFunctionInput{
FunctionName: in.FunctionName,
})
if err != nil {
return nil, err
}
size := uint64(len(in.ZipFile))
checksum := utils.Sha256(in.ZipFile)
remoteChecksum := *res.Configuration.CodeSha256
remoteSize := uint64(*res.Configuration.CodeSize)
if checksum != remoteChecksum {
l.create("function", *in.FunctionName, map[string]interface{}{
"size": fmt.Sprintf("%s -> %s", humanize.Bytes(remoteSize), humanize.Bytes(size)),
})
}
out := &lambda.FunctionConfiguration{
Version: aws.String("$LATEST"),
}
return out, nil
} | go | func (l *Lambda) UpdateFunctionCode(in *lambda.UpdateFunctionCodeInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunction(&lambda.GetFunctionInput{
FunctionName: in.FunctionName,
})
if err != nil {
return nil, err
}
size := uint64(len(in.ZipFile))
checksum := utils.Sha256(in.ZipFile)
remoteChecksum := *res.Configuration.CodeSha256
remoteSize := uint64(*res.Configuration.CodeSize)
if checksum != remoteChecksum {
l.create("function", *in.FunctionName, map[string]interface{}{
"size": fmt.Sprintf("%s -> %s", humanize.Bytes(remoteSize), humanize.Bytes(size)),
})
}
out := &lambda.FunctionConfiguration{
Version: aws.String("$LATEST"),
}
return out, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateFunctionCode",
"(",
"in",
"*",
"lambda",
".",
"UpdateFunctionCodeInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"l",
".",
"GetFunction",
"(",
"&",
"lambda",
".",
"GetFunctionInput",
"{",
"FunctionName",
":",
"in",
".",
"FunctionName",
",",
"}",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"size",
":=",
"uint64",
"(",
"len",
"(",
"in",
".",
"ZipFile",
")",
")",
"\n",
"checksum",
":=",
"utils",
".",
"Sha256",
"(",
"in",
".",
"ZipFile",
")",
"\n",
"remoteChecksum",
":=",
"*",
"res",
".",
"Configuration",
".",
"CodeSha256",
"\n",
"remoteSize",
":=",
"uint64",
"(",
"*",
"res",
".",
"Configuration",
".",
"CodeSize",
")",
"\n",
"if",
"checksum",
"!=",
"remoteChecksum",
"{",
"l",
".",
"create",
"(",
"\"function\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"size\"",
":",
"fmt",
".",
"Sprintf",
"(",
"\"%s -> %s\"",
",",
"humanize",
".",
"Bytes",
"(",
"remoteSize",
")",
",",
"humanize",
".",
"Bytes",
"(",
"size",
")",
")",
",",
"}",
")",
"\n",
"}",
"\n",
"out",
":=",
"&",
"lambda",
".",
"FunctionConfiguration",
"{",
"Version",
":",
"aws",
".",
"String",
"(",
"\"$LATEST\"",
")",
",",
"}",
"\n",
"return",
"out",
",",
"nil",
"\n",
"}"
] | // UpdateFunctionCode stub. | [
"UpdateFunctionCode",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L53-L78 | train |
apex/apex | dryrun/dryrun.go | UpdateFunctionConfiguration | func (l *Lambda) UpdateFunctionConfiguration(in *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunctionConfiguration(&lambda.GetFunctionConfigurationInput{
FunctionName: in.FunctionName,
})
if e, ok := err.(awserr.Error); ok {
if e.Code() == "ResourceNotFoundException" {
return nil, nil
}
}
if err != nil {
return nil, err
}
m := make(map[string]interface{})
if *in.Description != *res.Description {
m["description"] = fmt.Sprintf("%q -> %q", *res.Description, *in.Description)
}
if *in.Handler != *res.Handler {
m["handler"] = fmt.Sprintf("%s -> %s", *res.Handler, *in.Handler)
}
if *in.MemorySize != *res.MemorySize {
m["memory"] = fmt.Sprintf("%v -> %v", *res.MemorySize, *in.MemorySize)
}
if *in.Role != *res.Role {
m["role"] = fmt.Sprintf("%v -> %v", *res.Role, *in.Role)
}
if *in.Timeout != *res.Timeout {
m["timeout"] = fmt.Sprintf("%v -> %v", *res.Timeout, *in.Timeout)
}
if len(m) > 0 {
l.update("config", *in.FunctionName, m)
}
return nil, nil
} | go | func (l *Lambda) UpdateFunctionConfiguration(in *lambda.UpdateFunctionConfigurationInput) (*lambda.FunctionConfiguration, error) {
res, err := l.GetFunctionConfiguration(&lambda.GetFunctionConfigurationInput{
FunctionName: in.FunctionName,
})
if e, ok := err.(awserr.Error); ok {
if e.Code() == "ResourceNotFoundException" {
return nil, nil
}
}
if err != nil {
return nil, err
}
m := make(map[string]interface{})
if *in.Description != *res.Description {
m["description"] = fmt.Sprintf("%q -> %q", *res.Description, *in.Description)
}
if *in.Handler != *res.Handler {
m["handler"] = fmt.Sprintf("%s -> %s", *res.Handler, *in.Handler)
}
if *in.MemorySize != *res.MemorySize {
m["memory"] = fmt.Sprintf("%v -> %v", *res.MemorySize, *in.MemorySize)
}
if *in.Role != *res.Role {
m["role"] = fmt.Sprintf("%v -> %v", *res.Role, *in.Role)
}
if *in.Timeout != *res.Timeout {
m["timeout"] = fmt.Sprintf("%v -> %v", *res.Timeout, *in.Timeout)
}
if len(m) > 0 {
l.update("config", *in.FunctionName, m)
}
return nil, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateFunctionConfiguration",
"(",
"in",
"*",
"lambda",
".",
"UpdateFunctionConfigurationInput",
")",
"(",
"*",
"lambda",
".",
"FunctionConfiguration",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"l",
".",
"GetFunctionConfiguration",
"(",
"&",
"lambda",
".",
"GetFunctionConfigurationInput",
"{",
"FunctionName",
":",
"in",
".",
"FunctionName",
",",
"}",
")",
"\n",
"if",
"e",
",",
"ok",
":=",
"err",
".",
"(",
"awserr",
".",
"Error",
")",
";",
"ok",
"{",
"if",
"e",
".",
"Code",
"(",
")",
"==",
"\"ResourceNotFoundException\"",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"m",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"if",
"*",
"in",
".",
"Description",
"!=",
"*",
"res",
".",
"Description",
"{",
"m",
"[",
"\"description\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%q -> %q\"",
",",
"*",
"res",
".",
"Description",
",",
"*",
"in",
".",
"Description",
")",
"\n",
"}",
"\n",
"if",
"*",
"in",
".",
"Handler",
"!=",
"*",
"res",
".",
"Handler",
"{",
"m",
"[",
"\"handler\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%s -> %s\"",
",",
"*",
"res",
".",
"Handler",
",",
"*",
"in",
".",
"Handler",
")",
"\n",
"}",
"\n",
"if",
"*",
"in",
".",
"MemorySize",
"!=",
"*",
"res",
".",
"MemorySize",
"{",
"m",
"[",
"\"memory\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v -> %v\"",
",",
"*",
"res",
".",
"MemorySize",
",",
"*",
"in",
".",
"MemorySize",
")",
"\n",
"}",
"\n",
"if",
"*",
"in",
".",
"Role",
"!=",
"*",
"res",
".",
"Role",
"{",
"m",
"[",
"\"role\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v -> %v\"",
",",
"*",
"res",
".",
"Role",
",",
"*",
"in",
".",
"Role",
")",
"\n",
"}",
"\n",
"if",
"*",
"in",
".",
"Timeout",
"!=",
"*",
"res",
".",
"Timeout",
"{",
"m",
"[",
"\"timeout\"",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"%v -> %v\"",
",",
"*",
"res",
".",
"Timeout",
",",
"*",
"in",
".",
"Timeout",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"m",
")",
">",
"0",
"{",
"l",
".",
"update",
"(",
"\"config\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"m",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // UpdateFunctionConfiguration stub. | [
"UpdateFunctionConfiguration",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L81-L123 | train |
apex/apex | dryrun/dryrun.go | DeleteFunction | func (l *Lambda) DeleteFunction(in *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
if in.Qualifier == nil {
l.remove("function", *in.FunctionName, nil)
} else {
l.remove("function version", fmt.Sprintf("%s (version: %s)", *in.FunctionName, *in.Qualifier), nil)
}
return nil, nil
} | go | func (l *Lambda) DeleteFunction(in *lambda.DeleteFunctionInput) (*lambda.DeleteFunctionOutput, error) {
if in.Qualifier == nil {
l.remove("function", *in.FunctionName, nil)
} else {
l.remove("function version", fmt.Sprintf("%s (version: %s)", *in.FunctionName, *in.Qualifier), nil)
}
return nil, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"DeleteFunction",
"(",
"in",
"*",
"lambda",
".",
"DeleteFunctionInput",
")",
"(",
"*",
"lambda",
".",
"DeleteFunctionOutput",
",",
"error",
")",
"{",
"if",
"in",
".",
"Qualifier",
"==",
"nil",
"{",
"l",
".",
"remove",
"(",
"\"function\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"l",
".",
"remove",
"(",
"\"function version\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"%s (version: %s)\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"*",
"in",
".",
"Qualifier",
")",
",",
"nil",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // DeleteFunction stub. | [
"DeleteFunction",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L126-L134 | train |
apex/apex | dryrun/dryrun.go | CreateAlias | func (l *Lambda) CreateAlias(in *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
l.create("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | go | func (l *Lambda) CreateAlias(in *lambda.CreateAliasInput) (*lambda.AliasConfiguration, error) {
l.create("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"CreateAlias",
"(",
"in",
"*",
"lambda",
".",
"CreateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"l",
".",
"create",
"(",
"\"alias\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"alias\"",
":",
"*",
"in",
".",
"Name",
",",
"\"version\"",
":",
"*",
"in",
".",
"FunctionVersion",
",",
"}",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // CreateAlias stub. | [
"CreateAlias",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L137-L143 | train |
apex/apex | dryrun/dryrun.go | UpdateAlias | func (l *Lambda) UpdateAlias(in *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
l.update("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | go | func (l *Lambda) UpdateAlias(in *lambda.UpdateAliasInput) (*lambda.AliasConfiguration, error) {
l.update("alias", *in.FunctionName, map[string]interface{}{
"alias": *in.Name,
"version": *in.FunctionVersion,
})
return nil, nil
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"UpdateAlias",
"(",
"in",
"*",
"lambda",
".",
"UpdateAliasInput",
")",
"(",
"*",
"lambda",
".",
"AliasConfiguration",
",",
"error",
")",
"{",
"l",
".",
"update",
"(",
"\"alias\"",
",",
"*",
"in",
".",
"FunctionName",
",",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"alias\"",
":",
"*",
"in",
".",
"Name",
",",
"\"version\"",
":",
"*",
"in",
".",
"FunctionVersion",
",",
"}",
")",
"\n",
"return",
"nil",
",",
"nil",
"\n",
"}"
] | // UpdateAlias stub. | [
"UpdateAlias",
"stub",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L146-L152 | train |
apex/apex | dryrun/dryrun.go | create | func (l *Lambda) create(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '+', green)
} | go | func (l *Lambda) create(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '+', green)
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"create",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'+'",
",",
"green",
")",
"\n",
"}"
] | // create message. | [
"create",
"message",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L163-L165 | train |
apex/apex | dryrun/dryrun.go | update | func (l *Lambda) update(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '~', yellow)
} | go | func (l *Lambda) update(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '~', yellow)
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"update",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'~'",
",",
"yellow",
")",
"\n",
"}"
] | // update message. | [
"update",
"message",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L168-L170 | train |
apex/apex | dryrun/dryrun.go | remove | func (l *Lambda) remove(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '-', red)
} | go | func (l *Lambda) remove(kind, name string, m map[string]interface{}) {
l.log(kind, name, m, '-', red)
} | [
"func",
"(",
"l",
"*",
"Lambda",
")",
"remove",
"(",
"kind",
",",
"name",
"string",
",",
"m",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"log",
"(",
"kind",
",",
"name",
",",
"m",
",",
"'-'",
",",
"red",
")",
"\n",
"}"
] | // remove message. | [
"remove",
"message",
"."
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/dryrun/dryrun.go#L173-L175 | train |
apex/apex | mock/service/provider.go | NewMockProvideriface | func NewMockProvideriface(ctrl *gomock.Controller) *MockProvideriface {
mock := &MockProvideriface{ctrl: ctrl}
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
} | go | func NewMockProvideriface(ctrl *gomock.Controller) *MockProvideriface {
mock := &MockProvideriface{ctrl: ctrl}
mock.recorder = &MockProviderifaceMockRecorder{mock}
return mock
} | [
"func",
"NewMockProvideriface",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockProvideriface",
"{",
"mock",
":=",
"&",
"MockProvideriface",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockProviderifaceMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockProvideriface creates a new mock instance | [
"NewMockProvideriface",
"creates",
"a",
"new",
"mock",
"instance"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L27-L31 | train |
apex/apex | mock/service/provider.go | NewService | func (m *MockProvideriface) NewService(arg0 *aws.Config) lambdaiface.LambdaAPI {
if m.ctrl == nil {
return nil
}
ret := m.ctrl.Call(m, "NewService", arg0)
ret0, _ := ret[0].(lambdaiface.LambdaAPI)
return ret0
} | go | func (m *MockProvideriface) NewService(arg0 *aws.Config) lambdaiface.LambdaAPI {
if m.ctrl == nil {
return nil
}
ret := m.ctrl.Call(m, "NewService", arg0)
ret0, _ := ret[0].(lambdaiface.LambdaAPI)
return ret0
} | [
"func",
"(",
"m",
"*",
"MockProvideriface",
")",
"NewService",
"(",
"arg0",
"*",
"aws",
".",
"Config",
")",
"lambdaiface",
".",
"LambdaAPI",
"{",
"if",
"m",
".",
"ctrl",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"NewService\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"lambdaiface",
".",
"LambdaAPI",
")",
"\n",
"return",
"ret0",
"\n",
"}"
] | // NewService mocks base method | [
"NewService",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L39-L47 | train |
apex/apex | mock/service/provider.go | NewService | func (mr *MockProviderifaceMockRecorder) NewService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
} | go | func (mr *MockProviderifaceMockRecorder) NewService(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewService", reflect.TypeOf((*MockProvideriface)(nil).NewService), arg0)
} | [
"func",
"(",
"mr",
"*",
"MockProviderifaceMockRecorder",
")",
"NewService",
"(",
"arg0",
"interface",
"{",
"}",
")",
"*",
"gomock",
".",
"Call",
"{",
"return",
"mr",
".",
"mock",
".",
"ctrl",
".",
"RecordCallWithMethodType",
"(",
"mr",
".",
"mock",
",",
"\"NewService\"",
",",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"MockProvideriface",
")",
"(",
"nil",
")",
".",
"NewService",
")",
",",
"arg0",
")",
"\n",
"}"
] | // NewService indicates an expected call of NewService | [
"NewService",
"indicates",
"an",
"expected",
"call",
"of",
"NewService"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/service/provider.go#L50-L52 | train |
apex/apex | mock/lambdaiface.go | NewMockLambdaAPI | func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
mock := &MockLambdaAPI{ctrl: ctrl}
mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
} | go | func NewMockLambdaAPI(ctrl *gomock.Controller) *MockLambdaAPI {
mock := &MockLambdaAPI{ctrl: ctrl}
mock.recorder = &MockLambdaAPIMockRecorder{mock}
return mock
} | [
"func",
"NewMockLambdaAPI",
"(",
"ctrl",
"*",
"gomock",
".",
"Controller",
")",
"*",
"MockLambdaAPI",
"{",
"mock",
":=",
"&",
"MockLambdaAPI",
"{",
"ctrl",
":",
"ctrl",
"}",
"\n",
"mock",
".",
"recorder",
"=",
"&",
"MockLambdaAPIMockRecorder",
"{",
"mock",
"}",
"\n",
"return",
"mock",
"\n",
"}"
] | // NewMockLambdaAPI creates a new mock instance | [
"NewMockLambdaAPI",
"creates",
"a",
"new",
"mock",
"instance"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L27-L31 | train |
apex/apex | mock/lambdaiface.go | AddPermission | func (m *MockLambdaAPI) AddPermission(arg0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
ret := m.ctrl.Call(m, "AddPermission", arg0)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | func (m *MockLambdaAPI) AddPermission(arg0 *lambda.AddPermissionInput) (*lambda.AddPermissionOutput, error) {
ret := m.ctrl.Call(m, "AddPermission", arg0)
ret0, _ := ret[0].(*lambda.AddPermissionOutput)
ret1, _ := ret[1].(error)
return ret0, ret1
} | [
"func",
"(",
"m",
"*",
"MockLambdaAPI",
")",
"AddPermission",
"(",
"arg0",
"*",
"lambda",
".",
"AddPermissionInput",
")",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
",",
"error",
")",
"{",
"ret",
":=",
"m",
".",
"ctrl",
".",
"Call",
"(",
"m",
",",
"\"AddPermission\"",
",",
"arg0",
")",
"\n",
"ret0",
",",
"_",
":=",
"ret",
"[",
"0",
"]",
".",
"(",
"*",
"lambda",
".",
"AddPermissionOutput",
")",
"\n",
"ret1",
",",
"_",
":=",
"ret",
"[",
"1",
"]",
".",
"(",
"error",
")",
"\n",
"return",
"ret0",
",",
"ret1",
"\n",
"}"
] | // AddPermission mocks base method | [
"AddPermission",
"mocks",
"base",
"method"
] | c31f0a78ce189a8328563fa6a6eb97d04ace4284 | https://github.com/apex/apex/blob/c31f0a78ce189a8328563fa6a6eb97d04ace4284/mock/lambdaiface.go#L39-L44 | train |
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",
",",
"\"AddPermissionRequest\"",
",",
"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",
",",
"\"AddPermissionWithContext\"",
",",
"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",
",",
"\"CreateAlias\"",
",",
"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",
",",
"\"CreateAliasRequest\"",
",",
"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",
",",
"\"CreateAliasWithContext\"",
",",
"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",
",",
"\"CreateEventSourceMapping\"",
",",
"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",
",",
"\"CreateEventSourceMappingRequest\"",
",",
"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",
",",
"\"CreateFunction\"",
",",
"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",
",",
"\"CreateFunctionRequest\"",
",",
"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",
",",
"\"DeleteAlias\"",
",",
"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",
",",
"\"DeleteAliasRequest\"",
",",
"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",
",",
"\"DeleteAliasWithContext\"",
",",
"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",
",",
"\"DeleteEventSourceMapping\"",
",",
"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",
",",
"\"DeleteEventSourceMappingRequest\"",
",",
"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",
",",
"\"DeleteFunction\"",
",",
"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",
",",
"\"DeleteFunctionConcurrency\"",
",",
"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",
",",
"\"DeleteFunctionConcurrencyRequest\"",
",",
"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",
",",
"\"DeleteFunctionConcurrencyWithContext\"",
",",
"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",
",",
"\"DeleteFunctionRequest\"",
",",
"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",
",",
"\"DeleteFunctionWithContext\"",
",",
"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",
",",
"\"GetAccountSettings\"",
",",
"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",
",",
"\"GetAccountSettingsRequest\"",
",",
"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",
",",
"\"GetAccountSettingsWithContext\"",
",",
"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",
",",
"\"GetAlias\"",
",",
"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",
",",
"\"GetAliasRequest\"",
",",
"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",
",",
"\"GetEventSourceMapping\"",
",",
"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",
",",
"\"GetEventSourceMappingRequest\"",
",",
"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",
",",
"\"GetFunction\"",
",",
"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",
",",
"\"GetFunctionConfiguration\"",
",",
"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",
",",
"\"GetFunctionConfigurationRequest\"",
",",
"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",
",",
"\"GetFunctionConfigurationWithContext\"",
",",
"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",
",",
"\"GetFunctionRequest\"",
",",
"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",
",",
"\"GetFunctionWithContext\"",
",",
"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",
",",
"\"GetPolicy\"",
",",
"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",
",",
"\"GetPolicyRequest\"",
",",
"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",
",",
"\"GetPolicyWithContext\"",
",",
"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",
",",
"\"Invoke\"",
",",
"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",
",",
"\"InvokeAsync\"",
",",
"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",
",",
"\"InvokeAsyncRequest\"",
",",
"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",
",",
"\"InvokeAsyncWithContext\"",
",",
"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",
",",
"\"InvokeRequest\"",
",",
"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",
",",
"\"InvokeWithContext\"",
",",
"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",
",",
"\"ListAliases\"",
",",
"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",
",",
"\"ListAliasesRequest\"",
",",
"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",
",",
"\"ListAliasesRequest\"",
",",
"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",
",",
"\"ListAliasesWithContext\"",
",",
"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",
",",
"\"ListAliasesWithContext\"",
",",
"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",
",",
"\"ListEventSourceMappings\"",
",",
"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",
",",
"\"ListEventSourceMappingsPages\"",
",",
"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",
",",
"\"ListEventSourceMappingsRequest\"",
",",
"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",
",",
"\"ListEventSourceMappingsWithContext\"",
",",
"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",
",",
"\"ListFunctions\"",
",",
"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",
",",
"\"ListFunctionsPages\"",
",",
"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",
",",
"\"ListFunctionsPagesWithContext\"",
",",
"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",
",",
"\"ListFunctionsRequest\"",
",",
"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",
",",
"\"ListTags\"",
",",
"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",
",",
"\"ListTagsRequest\"",
",",
"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",
",",
"\"ListTagsWithContext\"",
",",
"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",
",",
"\"ListVersionsByFunction\"",
",",
"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",
",",
"\"ListVersionsByFunctionRequest\"",
",",
"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",
",",
"\"ListVersionsByFunctionWithContext\"",
",",
"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",
",",
"\"PublishVersion\"",
",",
"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",
",",
"\"PublishVersionRequest\"",
",",
"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",
",",
"\"PutFunctionConcurrency\"",
",",
"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",
",",
"\"PutFunctionConcurrencyRequest\"",
",",
"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",
",",
"\"PutFunctionConcurrencyWithContext\"",
",",
"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",
",",
"\"RemovePermission\"",
",",
"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",
",",
"\"RemovePermissionRequest\"",
",",
"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",
",",
"\"RemovePermissionWithContext\"",
",",
"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",
",",
"\"TagResource\"",
",",
"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",
",",
"\"TagResourceRequest\"",
",",
"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",
",",
"\"TagResourceWithContext\"",
",",
"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",
",",
"\"UntagResource\"",
",",
"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",
",",
"\"UntagResourceRequest\"",
",",
"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",
",",
"\"UpdateAlias\"",
",",
"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",
",",
"\"UpdateAliasRequest\"",
",",
"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",
",",
"\"UpdateEventSourceMapping\"",
",",
"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",
",",
"\"UpdateEventSourceMappingRequest\"",
",",
"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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.