mirror of
https://github.com/ceph/ceph-csi.git
synced 2025-06-13 02:33:34 +00:00
Madhu Rajanna
215
vendor/k8s.io/utils/exec/exec_test.go
generated
vendored
215
vendor/k8s.io/utils/exec/exec_test.go
generated
vendored
@ -1,215 +0,0 @@
|
||||
/*
|
||||
Copyright 2017 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 (
|
||||
"context"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
osexec "os/exec"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestExecutorNoArgs(t *testing.T) {
|
||||
ex := New()
|
||||
|
||||
cmd := ex.Command("true")
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Errorf("expected success, got %v", err)
|
||||
}
|
||||
if len(out) != 0 {
|
||||
t.Errorf("expected no output, got %q", string(out))
|
||||
}
|
||||
|
||||
cmd = ex.Command("false")
|
||||
out, err = cmd.CombinedOutput()
|
||||
if err == nil {
|
||||
t.Errorf("expected failure, got nil error")
|
||||
}
|
||||
if len(out) != 0 {
|
||||
t.Errorf("expected no output, got %q", string(out))
|
||||
}
|
||||
ee, ok := err.(ExitError)
|
||||
if !ok {
|
||||
t.Errorf("expected an ExitError, got %+v", err)
|
||||
}
|
||||
if ee.Exited() {
|
||||
if code := ee.ExitStatus(); code != 1 {
|
||||
t.Errorf("expected exit status 1, got %d", code)
|
||||
}
|
||||
}
|
||||
|
||||
cmd = ex.Command("/does/not/exist")
|
||||
out, err = cmd.CombinedOutput()
|
||||
if err == nil {
|
||||
t.Errorf("expected failure, got nil error")
|
||||
}
|
||||
if ee, ok := err.(ExitError); ok {
|
||||
t.Errorf("expected non-ExitError, got %+v", ee)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecutorWithArgs(t *testing.T) {
|
||||
ex := New()
|
||||
|
||||
cmd := ex.Command("echo", "stdout")
|
||||
out, err := cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Errorf("expected success, got %+v", err)
|
||||
}
|
||||
if string(out) != "stdout\n" {
|
||||
t.Errorf("unexpected output: %q", string(out))
|
||||
}
|
||||
|
||||
cmd = ex.Command("/bin/sh", "-c", "echo stderr > /dev/stderr")
|
||||
out, err = cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Errorf("expected success, got %+v", err)
|
||||
}
|
||||
if string(out) != "stderr\n" {
|
||||
t.Errorf("unexpected output: %q", string(out))
|
||||
}
|
||||
}
|
||||
|
||||
func TestLookPath(t *testing.T) {
|
||||
ex := New()
|
||||
|
||||
shExpected, _ := osexec.LookPath("sh")
|
||||
sh, _ := ex.LookPath("sh")
|
||||
if sh != shExpected {
|
||||
t.Errorf("unexpected result for LookPath: got %s, expected %s", sh, shExpected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExecutableNotFound(t *testing.T) {
|
||||
exec := New()
|
||||
|
||||
cmd := exec.Command("fake_executable_name")
|
||||
_, err := cmd.CombinedOutput()
|
||||
if err != ErrExecutableNotFound {
|
||||
t.Errorf("cmd.CombinedOutput(): Expected error ErrExecutableNotFound but got %v", err)
|
||||
}
|
||||
|
||||
cmd = exec.Command("fake_executable_name")
|
||||
_, err = cmd.Output()
|
||||
if err != ErrExecutableNotFound {
|
||||
t.Errorf("cmd.Output(): Expected error ErrExecutableNotFound but got %v", err)
|
||||
}
|
||||
|
||||
cmd = exec.Command("fake_executable_name")
|
||||
err = cmd.Run()
|
||||
if err != ErrExecutableNotFound {
|
||||
t.Errorf("cmd.Run(): Expected error ErrExecutableNotFound but got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStopBeforeStart(t *testing.T) {
|
||||
cmd := New().Command("echo", "hello")
|
||||
|
||||
// no panic calling Stop before calling Run
|
||||
cmd.Stop()
|
||||
|
||||
cmd.Run()
|
||||
|
||||
// no panic calling Stop after command is done
|
||||
cmd.Stop()
|
||||
}
|
||||
|
||||
func TestTimeout(t *testing.T) {
|
||||
exec := New()
|
||||
ctx, cancel := context.WithTimeout(context.Background(), time.Nanosecond)
|
||||
defer cancel()
|
||||
|
||||
err := exec.CommandContext(ctx, "sleep", "2").Run()
|
||||
if err != context.DeadlineExceeded {
|
||||
t.Errorf("expected %v but got %v", context.DeadlineExceeded, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSetEnv(t *testing.T) {
|
||||
ex := New()
|
||||
|
||||
out, err := ex.Command("/bin/sh", "-c", "echo $FOOBAR").CombinedOutput()
|
||||
if err != nil {
|
||||
t.Errorf("expected success, got %+v", err)
|
||||
}
|
||||
if string(out) != "\n" {
|
||||
t.Errorf("unexpected output: %q", string(out))
|
||||
}
|
||||
|
||||
cmd := ex.Command("/bin/sh", "-c", "echo $FOOBAR")
|
||||
cmd.SetEnv([]string{"FOOBAR=baz"})
|
||||
out, err = cmd.CombinedOutput()
|
||||
if err != nil {
|
||||
t.Errorf("expected success, got %+v", err)
|
||||
}
|
||||
if string(out) != "baz\n" {
|
||||
t.Errorf("unexpected output: %q", string(out))
|
||||
}
|
||||
}
|
||||
|
||||
func TestStdIOPipes(t *testing.T) {
|
||||
cmd := New().Command("/bin/sh", "-c", "echo 'OUT'>&1; echo 'ERR'>&2")
|
||||
|
||||
stdoutPipe, err := cmd.StdoutPipe()
|
||||
if err != nil {
|
||||
t.Fatalf("expected StdoutPipe() not to error, got: %v", err)
|
||||
}
|
||||
stderrPipe, err := cmd.StderrPipe()
|
||||
if err != nil {
|
||||
t.Fatalf("expected StderrPipe() not to error, got: %v", err)
|
||||
}
|
||||
|
||||
stdout := make(chan string)
|
||||
stderr := make(chan string)
|
||||
|
||||
go func() {
|
||||
stdout <- readAll(t, stdoutPipe, "StdOut")
|
||||
}()
|
||||
go func() {
|
||||
stderr <- readAll(t, stderrPipe, "StdErr")
|
||||
}()
|
||||
|
||||
if err := cmd.Start(); err != nil {
|
||||
t.Errorf("expected Start() not to error, got: %v", err)
|
||||
}
|
||||
|
||||
if e, a := "OUT\n", <-stdout; e != a {
|
||||
t.Errorf("expected StdOut to be '%s', got: '%v'", e, a)
|
||||
}
|
||||
|
||||
if e, a := "ERR\n", <-stderr; e != a {
|
||||
t.Errorf("expected StdErr to be '%s', got: '%v'", e, a)
|
||||
}
|
||||
|
||||
if err := cmd.Wait(); err != nil {
|
||||
t.Errorf("expected Wait() not to error, got: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func readAll(t *testing.T, r io.Reader, n string) string {
|
||||
t.Helper()
|
||||
|
||||
b, err := ioutil.ReadAll(r)
|
||||
if err != nil {
|
||||
t.Fatalf("unexpected error when reading from %s: %v", n, err)
|
||||
}
|
||||
|
||||
return string(b)
|
||||
}
|
||||
37
vendor/k8s.io/utils/exec/new_test.go
generated
vendored
37
vendor/k8s.io/utils/exec/new_test.go
generated
vendored
@ -1,37 +0,0 @@
|
||||
/*
|
||||
Copyright 2017 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_test
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
|
||||
"k8s.io/utils/exec"
|
||||
)
|
||||
|
||||
func ExampleNew() {
|
||||
exec := exec.New()
|
||||
|
||||
cmd := exec.Command("echo", "Bonjour!")
|
||||
buff := bytes.Buffer{}
|
||||
cmd.SetStdout(&buff)
|
||||
if err := cmd.Run(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
fmt.Println(buff.String())
|
||||
// Output: Bonjour!
|
||||
}
|
||||
55
vendor/k8s.io/utils/exec/stdiopipe_test.go
generated
vendored
55
vendor/k8s.io/utils/exec/stdiopipe_test.go
generated
vendored
@ -1,55 +0,0 @@
|
||||
/*
|
||||
Copyright 2018 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_test
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
|
||||
"k8s.io/utils/exec"
|
||||
)
|
||||
|
||||
func ExampleNew_stderrPipe() {
|
||||
cmd := exec.New().Command("/bin/sh", "-c", "echo 'We can read from stderr via pipe!' >&2")
|
||||
|
||||
stderrPipe, err := cmd.StderrPipe()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
stderr := make(chan []byte)
|
||||
go func() {
|
||||
b, err := ioutil.ReadAll(stderrPipe)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
stderr <- b
|
||||
}()
|
||||
|
||||
if err := cmd.Start(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
received := <-stderr
|
||||
|
||||
if err := cmd.Wait(); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
fmt.Println(string(received))
|
||||
// Output: We can read from stderr via pipe!
|
||||
}
|
||||
217
vendor/k8s.io/utils/exec/testing/fake_exec.go
generated
vendored
217
vendor/k8s.io/utils/exec/testing/fake_exec.go
generated
vendored
@ -1,217 +0,0 @@
|
||||
/*
|
||||
Copyright 2017 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 testingexec
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"k8s.io/utils/exec"
|
||||
)
|
||||
|
||||
// FakeExec is a simple scripted Interface type.
|
||||
type FakeExec struct {
|
||||
CommandScript []FakeCommandAction
|
||||
CommandCalls int
|
||||
LookPathFunc func(string) (string, error)
|
||||
}
|
||||
|
||||
var _ exec.Interface = &FakeExec{}
|
||||
|
||||
// FakeCommandAction is the function to be executed
|
||||
type FakeCommandAction func(cmd string, args ...string) exec.Cmd
|
||||
|
||||
// Command is to track the commands that are executed
|
||||
func (fake *FakeExec) Command(cmd string, args ...string) exec.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...)
|
||||
}
|
||||
|
||||
// CommandContext wraps arguments into exec.Cmd
|
||||
func (fake *FakeExec) CommandContext(ctx context.Context, cmd string, args ...string) exec.Cmd {
|
||||
return fake.Command(cmd, args...)
|
||||
}
|
||||
|
||||
// LookPath is for finding the path of a file
|
||||
func (fake *FakeExec) LookPath(file string) (string, error) {
|
||||
return fake.LookPathFunc(file)
|
||||
}
|
||||
|
||||
// FakeCmd is 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
|
||||
Env []string
|
||||
StdoutPipeResponse FakeStdIOPipeResponse
|
||||
StderrPipeResponse FakeStdIOPipeResponse
|
||||
WaitResponse error
|
||||
StartResponse error
|
||||
}
|
||||
|
||||
var _ exec.Cmd = &FakeCmd{}
|
||||
|
||||
// InitFakeCmd is for creating a fake exec.Cmd
|
||||
func InitFakeCmd(fake *FakeCmd, cmd string, args ...string) exec.Cmd {
|
||||
fake.Argv = append([]string{cmd}, args...)
|
||||
return fake
|
||||
}
|
||||
|
||||
// FakeStdIOPipeResponse holds responses to use as fakes for the StdoutPipe and
|
||||
// StderrPipe method calls
|
||||
type FakeStdIOPipeResponse struct {
|
||||
ReadCloser io.ReadCloser
|
||||
Error error
|
||||
}
|
||||
|
||||
// FakeCombinedOutputAction is a function type
|
||||
type FakeCombinedOutputAction func() ([]byte, error)
|
||||
|
||||
// FakeRunAction is a function type
|
||||
type FakeRunAction func() ([]byte, []byte, error)
|
||||
|
||||
// SetDir sets the directory
|
||||
func (fake *FakeCmd) SetDir(dir string) {
|
||||
fake.Dirs = append(fake.Dirs, dir)
|
||||
}
|
||||
|
||||
// SetStdin sets the stdin
|
||||
func (fake *FakeCmd) SetStdin(in io.Reader) {
|
||||
fake.Stdin = in
|
||||
}
|
||||
|
||||
// SetStdout sets the stdout
|
||||
func (fake *FakeCmd) SetStdout(out io.Writer) {
|
||||
fake.Stdout = out
|
||||
}
|
||||
|
||||
// SetStderr sets the stderr
|
||||
func (fake *FakeCmd) SetStderr(out io.Writer) {
|
||||
fake.Stderr = out
|
||||
}
|
||||
|
||||
// SetEnv sets the environment variables
|
||||
func (fake *FakeCmd) SetEnv(env []string) {
|
||||
fake.Env = env
|
||||
}
|
||||
|
||||
// StdoutPipe returns an injected ReadCloser & error (via StdoutPipeResponse)
|
||||
// to be able to inject an output stream on Stdout
|
||||
func (fake *FakeCmd) StdoutPipe() (io.ReadCloser, error) {
|
||||
return fake.StdoutPipeResponse.ReadCloser, fake.StdoutPipeResponse.Error
|
||||
}
|
||||
|
||||
// StderrPipe returns an injected ReadCloser & error (via StderrPipeResponse)
|
||||
// to be able to inject an output stream on Stderr
|
||||
func (fake *FakeCmd) StderrPipe() (io.ReadCloser, error) {
|
||||
return fake.StderrPipeResponse.ReadCloser, fake.StderrPipeResponse.Error
|
||||
}
|
||||
|
||||
// Start mimicks starting the process (in the background) and returns the
|
||||
// injected StartResponse
|
||||
func (fake *FakeCmd) Start() error {
|
||||
return fake.StartResponse
|
||||
}
|
||||
|
||||
// Wait mimicks waiting for the process to exit returns the
|
||||
// injected WaitResponse
|
||||
func (fake *FakeCmd) Wait() error {
|
||||
return fake.WaitResponse
|
||||
}
|
||||
|
||||
// Run sets runs the command
|
||||
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
|
||||
}
|
||||
|
||||
// CombinedOutput returns the output from the command
|
||||
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]()
|
||||
}
|
||||
|
||||
// Output is the response from the command
|
||||
func (fake *FakeCmd) Output() ([]byte, error) {
|
||||
return nil, fmt.Errorf("unimplemented")
|
||||
}
|
||||
|
||||
// Stop is to stop the process
|
||||
func (fake *FakeCmd) Stop() {
|
||||
// no-op
|
||||
}
|
||||
|
||||
// FakeExitError is a simple fake ExitError type.
|
||||
type FakeExitError struct {
|
||||
Status int
|
||||
}
|
||||
|
||||
var _ exec.ExitError = FakeExitError{}
|
||||
|
||||
func (fake FakeExitError) String() string {
|
||||
return fmt.Sprintf("exit %d", fake.Status)
|
||||
}
|
||||
|
||||
func (fake FakeExitError) Error() string {
|
||||
return fake.String()
|
||||
}
|
||||
|
||||
// Exited always returns true
|
||||
func (fake FakeExitError) Exited() bool {
|
||||
return true
|
||||
}
|
||||
|
||||
// ExitStatus returns the fake status
|
||||
func (fake FakeExitError) ExitStatus() int {
|
||||
return fake.Status
|
||||
}
|
||||
Reference in New Issue
Block a user