exec

Documentation

Overview

Package exec provides an injectable interface and implementations for running commands.

Index

• Variables
• type Cmd
  • func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) Cmd
• type CodeExitError
  • func (e CodeExitError) Error() string
  • func (e CodeExitError) ExitStatus() int
  • func (e CodeExitError) Exited() bool
  • func (e CodeExitError) String() string
• type ExitError
• type ExitErrorWrapper
  • func (eew ExitErrorWrapper) ExitStatus() int
• type FakeCmd
  • func (fake *FakeCmd) CombinedOutput() ([]byte, error)
  • func (fake *FakeCmd) Output() ([]byte, error)
  • func (fake *FakeCmd) SetDir(dir string)
  • func (fake *FakeCmd) SetStdin(in io.Reader)
  • func (fake *FakeCmd) SetStdout(out io.Writer)
• type FakeCombinedOutputAction
• type FakeCommandAction
• type FakeExec
  • func (fake *FakeExec) Command(cmd string, args ...string) Cmd
  • func (fake *FakeExec) LookPath(file string) (string, error)
• type FakeExitError
  • func (fake *FakeExitError) Error() string
  • func (fake *FakeExitError) ExitStatus() int
  • func (fake *FakeExitError) Exited() bool
  • func (fake *FakeExitError) String() string
• type Interface
  • func New() Interface

Variables

var ErrExecutableNotFound = osexec.ErrNotFound

ErrExecutableNotFound is returned if the executable is not found.

Types

type Cmd

type Cmd interface {
	// CombinedOutput runs the command and returns its combined standard output
	// and standard error.  This follows the pattern of package os/exec.
	CombinedOutput() ([]byte, error)
	// Output runs the command and returns standard output, but not standard err
	Output() ([]byte, error)
	SetDir(dir string)
	SetStdin(in io.Reader)
	SetStdout(out io.Writer)
}

Cmd is an interface that presents an API that is very similar to Cmd from os/exec. As more functionality is needed, this can grow. Since Cmd is a struct, we will have to replace fields with get/set method pairs.

func InitFakeCmd

func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) Cmd

type CodeExitError

type CodeExitError struct {
	Err  error
	Code int
}

CodeExitError is an implementation of ExitError consisting of an error object and an exit code (the upper bits of os.exec.ExitStatus).

func (CodeExitError) Error

func (e CodeExitError) Error() string

func (CodeExitError) ExitStatus

func (e CodeExitError) ExitStatus() int

func (CodeExitError) Exited

func (e CodeExitError) Exited() bool

func (CodeExitError) String

func (e CodeExitError) String() string

type ExitError

type ExitError interface {
	String() string
	Error() string
	Exited() bool
	ExitStatus() int
}

ExitError is an interface that presents an API similar to os.ProcessState, which is what ExitError from os/exec is. This is designed to make testing a bit easier and probably loses some of the cross-platform properties of the underlying library.

type ExitErrorWrapper

type ExitErrorWrapper struct {
	*osexec.ExitError
}

ExitErrorWrapper is an implementation of ExitError in terms of os/exec ExitError. Note: standard exec.ExitError is type *os.ProcessState, which already implements Exited().

func (ExitErrorWrapper) ExitStatus

func (eew ExitErrorWrapper) ExitStatus() int

ExitStatus is part of the ExitError interface.

type FakeCmd

type FakeCmd struct {
	Argv                 []string
	CombinedOutputScript []FakeCombinedOutputAction
	CombinedOutputCalls  int
	CombinedOutputLog    [][]string
	Dirs                 []string
	Stdin                io.Reader
	Stdout               io.Writer
}

A simple scripted Cmd type.

func (*FakeCmd) CombinedOutput

func (fake *FakeCmd) CombinedOutput() ([]byte, error)

func (*FakeCmd) Output

func (fake *FakeCmd) Output() ([]byte, error)

func (*FakeCmd) SetDir

func (fake *FakeCmd) SetDir(dir string)

func (*FakeCmd) SetStdin

func (fake *FakeCmd) SetStdin(in io.Reader)

func (*FakeCmd) SetStdout

func (fake *FakeCmd) SetStdout(out io.Writer)

type FakeCombinedOutputAction

type FakeCombinedOutputAction func() ([]byte, error)

type FakeCommandAction

type FakeCommandAction func(cmd string, args ...string) Cmd

type FakeExec

type FakeExec struct {
	CommandScript []FakeCommandAction
	CommandCalls  int
	LookPathFunc  func(string) (string, error)
}

A simple scripted Interface type.

func (*FakeExec) Command

func (fake *FakeExec) Command(cmd string, args ...string) Cmd

func (*FakeExec) LookPath

func (fake *FakeExec) LookPath(file string) (string, error)

type FakeExitError

type FakeExitError struct {
	Status int
}

A simple fake ExitError type.

func (*FakeExitError) Error

func (fake *FakeExitError) Error() string

func (*FakeExitError) ExitStatus

func (fake *FakeExitError) ExitStatus() int

func (*FakeExitError) Exited

func (fake *FakeExitError) Exited() bool

func (*FakeExitError) String

func (fake *FakeExitError) String() string

type Interface

type Interface interface {
	// Command returns a Cmd instance which can be used to run a single command.
	// This follows the pattern of package os/exec.
	Command(cmd string, args ...string) Cmd

	// LookPath wraps os/exec.LookPath
	LookPath(file string) (string, error)
}

Interface is an interface that presents a subset of the os/exec API. Use this when you want to inject fakeable/mockable exec behavior.

func New

func New() Interface

New returns a new Interface which will os/exec to run commands.