145 lines
3.5 KiB
Go
145 lines
3.5 KiB
Go
/*
|
|
Copyright 2014 The Kubernetes Authors.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package exec
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
)
|
|
|
|
// A simple scripted Interface type.
|
|
type FakeExec struct {
|
|
CommandScript []FakeCommandAction
|
|
CommandCalls int
|
|
LookPathFunc func(string) (string, error)
|
|
}
|
|
|
|
type FakeCommandAction func(cmd string, args ...string) Cmd
|
|
|
|
func (fake *FakeExec) Command(cmd string, args ...string) Cmd {
|
|
if fake.CommandCalls > len(fake.CommandScript)-1 {
|
|
panic(fmt.Sprintf("ran out of Command() actions. Could not handle command [%d]: %s args: %v", fake.CommandCalls, cmd, args))
|
|
}
|
|
i := fake.CommandCalls
|
|
fake.CommandCalls++
|
|
return fake.CommandScript[i](cmd, args...)
|
|
}
|
|
|
|
func (fake *FakeExec) LookPath(file string) (string, error) {
|
|
return fake.LookPathFunc(file)
|
|
}
|
|
|
|
// A simple scripted Cmd type.
|
|
type FakeCmd struct {
|
|
Argv []string
|
|
CombinedOutputScript []FakeCombinedOutputAction
|
|
CombinedOutputCalls int
|
|
CombinedOutputLog [][]string
|
|
RunScript []FakeRunAction
|
|
RunCalls int
|
|
RunLog [][]string
|
|
Dirs []string
|
|
Stdin io.Reader
|
|
Stdout io.Writer
|
|
Stderr io.Writer
|
|
}
|
|
|
|
func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) Cmd {
|
|
fake.Argv = append([]string{cmd}, args...)
|
|
return fake
|
|
}
|
|
|
|
type FakeCombinedOutputAction func() ([]byte, error)
|
|
type FakeRunAction func() ([]byte, []byte, error)
|
|
|
|
func (fake *FakeCmd) SetDir(dir string) {
|
|
fake.Dirs = append(fake.Dirs, dir)
|
|
}
|
|
|
|
func (fake *FakeCmd) SetStdin(in io.Reader) {
|
|
fake.Stdin = in
|
|
}
|
|
|
|
func (fake *FakeCmd) SetStdout(out io.Writer) {
|
|
fake.Stdout = out
|
|
}
|
|
|
|
func (fake *FakeCmd) SetStderr(out io.Writer) {
|
|
fake.Stderr = out
|
|
}
|
|
|
|
func (fake *FakeCmd) Run() error {
|
|
if fake.RunCalls > len(fake.RunScript)-1 {
|
|
panic("ran out of Run() actions")
|
|
}
|
|
if fake.RunLog == nil {
|
|
fake.RunLog = [][]string{}
|
|
}
|
|
i := fake.RunCalls
|
|
fake.RunLog = append(fake.RunLog, append([]string{}, fake.Argv...))
|
|
fake.RunCalls++
|
|
stdout, stderr, err := fake.RunScript[i]()
|
|
if stdout != nil {
|
|
fake.Stdout.Write(stdout)
|
|
}
|
|
if stderr != nil {
|
|
fake.Stderr.Write(stderr)
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (fake *FakeCmd) CombinedOutput() ([]byte, error) {
|
|
if fake.CombinedOutputCalls > len(fake.CombinedOutputScript)-1 {
|
|
panic("ran out of CombinedOutput() actions")
|
|
}
|
|
if fake.CombinedOutputLog == nil {
|
|
fake.CombinedOutputLog = [][]string{}
|
|
}
|
|
i := fake.CombinedOutputCalls
|
|
fake.CombinedOutputLog = append(fake.CombinedOutputLog, append([]string{}, fake.Argv...))
|
|
fake.CombinedOutputCalls++
|
|
return fake.CombinedOutputScript[i]()
|
|
}
|
|
|
|
func (fake *FakeCmd) Output() ([]byte, error) {
|
|
return nil, fmt.Errorf("unimplemented")
|
|
}
|
|
|
|
func (fake *FakeCmd) Stop() {
|
|
// no-op
|
|
}
|
|
|
|
// A simple fake ExitError type.
|
|
type FakeExitError struct {
|
|
Status int
|
|
}
|
|
|
|
func (fake *FakeExitError) String() string {
|
|
return fmt.Sprintf("exit %d", fake.Status)
|
|
}
|
|
|
|
func (fake *FakeExitError) Error() string {
|
|
return fake.String()
|
|
}
|
|
|
|
func (fake *FakeExitError) Exited() bool {
|
|
return true
|
|
}
|
|
|
|
func (fake *FakeExitError) ExitStatus() int {
|
|
return fake.Status
|
|
}
|