136 lines
2.9 KiB
Go
136 lines
2.9 KiB
Go
package oscmd
|
|
|
|
import (
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestRunTrimsStdout(t *testing.T) {
|
|
out, err := Run("echo", "hello")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if out != "hello" {
|
|
t.Errorf("got %q, want %q", out, "hello")
|
|
}
|
|
}
|
|
|
|
func TestRunSurfacesStderr(t *testing.T) {
|
|
_, err := Run("sh", "-c", "echo boom >&2; exit 1")
|
|
if err == nil || !strings.Contains(err.Error(), "boom") {
|
|
t.Fatalf("expected stderr 'boom' in error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRunMissingBinary(t *testing.T) {
|
|
if _, err := Run("definitely-not-a-real-binary-xyz"); err == nil {
|
|
t.Fatal("expected error for missing binary")
|
|
}
|
|
}
|
|
|
|
func TestRunLines(t *testing.T) {
|
|
got, err := RunLines("printf", `a\nb\nc\n`)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
want := []string{"a", "b", "c"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Errorf("got %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRunLinesEmpty(t *testing.T) {
|
|
got, err := RunLines("true")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(got) != 0 {
|
|
t.Errorf("empty output should yield no lines, got %v", got)
|
|
}
|
|
}
|
|
|
|
func TestOK(t *testing.T) {
|
|
if OK().Body.Status != "ok" {
|
|
t.Error("OK() should report status ok")
|
|
}
|
|
}
|
|
|
|
func TestRunStdin(t *testing.T) {
|
|
SetMock("cat", func(args []string) MockCommand {
|
|
return MockCommand{Stdout: "piped input data", ExitCode: 0}
|
|
})
|
|
defer ClearMocks()
|
|
|
|
got, err := RunStdin("some input", "cat")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got != "piped input data" {
|
|
t.Errorf("got %q, want %q", got, "piped input data")
|
|
}
|
|
}
|
|
|
|
func TestRunStatus(t *testing.T) {
|
|
SetMock("check-update", func(args []string) MockCommand {
|
|
return MockCommand{Stdout: "updates available", ExitCode: 100}
|
|
})
|
|
defer ClearMocks()
|
|
|
|
out, code, err := RunStatus("check-update")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if out != "updates available" || code != 100 {
|
|
t.Errorf("got out=%q code=%d, want out=%q code=100", out, code, "updates available")
|
|
}
|
|
}
|
|
|
|
func TestRunStream(t *testing.T) {
|
|
SetMock("stream-cmd", func(args []string) MockCommand {
|
|
return MockCommand{Lines: []string{"line1", "line2"}, DelayMs: 1}
|
|
})
|
|
defer ClearMocks()
|
|
|
|
ch, err := RunStream(t.Context(), "stream-cmd")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var got []string
|
|
for line := range ch {
|
|
got = append(got, line)
|
|
}
|
|
|
|
want := []string{"line1", "line2"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Errorf("got %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRunStreamCombined(t *testing.T) {
|
|
SetMock("combined-cmd", func(args []string) MockCommand {
|
|
return MockCommand{Lines: []string{"output1", "output2"}, ExitCode: 0}
|
|
})
|
|
defer ClearMocks()
|
|
|
|
lines, errc, err := RunStreamCombined(t.Context(), nil, "combined-cmd")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var got []string
|
|
for line := range lines {
|
|
got = append(got, line)
|
|
}
|
|
|
|
if err := <-errc; err != nil {
|
|
t.Errorf("stream failed with error: %v", err)
|
|
}
|
|
|
|
want := []string{"output1", "output2"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Errorf("got %v, want %v", got, want)
|
|
}
|
|
}
|