forked from rook/rook
-
Notifications
You must be signed in to change notification settings - Fork 0
/
mockexec.go
143 lines (120 loc) · 5.04 KB
/
mockexec.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
/*
Copyright 2016 The Rook Authors. All rights reserved.
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 test
import (
"errors"
"fmt"
"os"
"os/exec"
"strconv"
"testing"
"time"
)
// MockExecutor mocks all the exec commands
type MockExecutor struct {
MockExecuteCommand func(command string, arg ...string) error
MockExecuteCommandWithEnv func(env []string, command string, arg ...string) error
MockStartExecuteCommand func(command string, arg ...string) (*exec.Cmd, error)
MockExecuteCommandWithOutput func(command string, arg ...string) (string, error)
MockExecuteCommandWithCombinedOutput func(command string, arg ...string) (string, error)
MockExecuteCommandWithTimeout func(timeout time.Duration, command string, arg ...string) (string, error)
MockExecuteCommandWithStdin func(timeout time.Duration, command string, stdin *string, arg ...string) error
}
// ExecuteCommand mocks ExecuteCommand
func (e *MockExecutor) ExecuteCommand(command string, arg ...string) error {
if e.MockExecuteCommand != nil {
return e.MockExecuteCommand(command, arg...)
}
return nil
}
// ExecuteCommandWithStdin starts a process, provides stdin and wait for its completion with timeout.
func (e *MockExecutor) ExecuteCommandWithStdin(timeout time.Duration, command string, stdin *string, arg ...string) error {
if e.MockExecuteCommand != nil {
return e.MockExecuteCommandWithStdin(timeout, command, stdin, arg...)
}
return nil
}
// ExecuteCommandWithEnv mocks ExecuteCommandWithEnv
func (e *MockExecutor) ExecuteCommandWithEnv(env []string, command string, arg ...string) error {
if e.MockExecuteCommandWithEnv != nil {
return e.MockExecuteCommandWithEnv(env, command, arg...)
}
return nil
}
// ExecuteCommandWithOutput mocks ExecuteCommandWithOutput
func (e *MockExecutor) ExecuteCommandWithOutput(command string, arg ...string) (string, error) {
if e.MockExecuteCommandWithOutput != nil {
return e.MockExecuteCommandWithOutput(command, arg...)
}
return "", nil
}
// ExecuteCommandWithTimeout mocks ExecuteCommandWithTimeout
func (e *MockExecutor) ExecuteCommandWithTimeout(timeout time.Duration, command string, arg ...string) (string, error) {
if e.MockExecuteCommandWithTimeout != nil {
return e.MockExecuteCommandWithTimeout(time.Second, command, arg...)
}
return "", nil
}
// ExecuteCommandWithCombinedOutput mocks ExecuteCommandWithCombinedOutput
func (e *MockExecutor) ExecuteCommandWithCombinedOutput(command string, arg ...string) (string, error) {
if e.MockExecuteCommandWithCombinedOutput != nil {
return e.MockExecuteCommandWithCombinedOutput(command, arg...)
}
return "", nil
}
// Mock an executed command with the desired return values.
// STDERR is returned *before* STDOUT.
//
// This will return an error if the given exit code is nonzero. The error return is the primary
// benefit of using this method.
//
// In order for this to work in a `*_test.go` file, you MUST import TestMockExecHelperProcess
// exactly as shown below:
//
// import exectest "github.com/rook/rook/pkg/util/exec/test"
// // import TestMockExecHelperProcess
// func TestMockExecHelperProcess(t *testing.T) {
// exectest.TestMockExecHelperProcess(t)
// }
//
// Inspired by: https://github.com/golang/go/blob/master/src/os/exec/exec_test.go
func MockExecCommandReturns(t *testing.T, stdout, stderr string, retcode int) error {
cmd := exec.Command(os.Args[0], "-test.run=TestMockExecHelperProcess") //nolint:gosec //Rook controls the input to the exec arguments
cmd.Env = append(os.Environ(),
"GO_WANT_HELPER_PROCESS=1",
fmt.Sprintf("GO_HELPER_PROCESS_STDOUT=%s", stdout),
fmt.Sprintf("GO_HELPER_PROCESS_STDERR=%s", stderr),
fmt.Sprintf("GO_HELPER_PROCESS_RETCODE=%d", retcode),
)
err := cmd.Run()
return err
}
// TestHelperProcess isn't a real test. It's used as a helper process for MockExecCommandReturns to
// simulate output from a command. Notably, this can return a realistic os/exec error.
// Inspired by: https://github.com/golang/go/blob/master/src/os/exec/exec_test.go
func TestMockExecHelperProcess(t *testing.T) {
if os.Getenv("GO_WANT_HELPER_PROCESS") != "1" {
return
}
// test should set these in its environment to control the output of the test commands
fmt.Fprint(os.Stderr, os.Getenv("GO_HELPER_PROCESS_STDERR")) // return stderr before stdout
fmt.Fprint(os.Stdout, os.Getenv("GO_HELPER_PROCESS_STDOUT"))
rc, err := strconv.Atoi(os.Getenv("GO_HELPER_PROCESS_RETCODE"))
if err != nil {
panic(err)
}
os.Exit(rc)
}
func FakeTimeoutError(text string) error {
return errors.New(fmt.Sprintf("exec timeout waiting for %s", text))
}