forked from rhysd/notes-cli
-
Notifications
You must be signed in to change notification settings - Fork 0
/
external_test.go
140 lines (120 loc) · 3.51 KB
/
external_test.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
package notes
import (
"errors"
"fmt"
"github.com/rhysd/go-fakeio"
"github.com/rhysd/go-tmpenv"
"os"
"path/filepath"
"reflect"
"runtime"
"strings"
"testing"
)
func TestNewExternalCmdOK(t *testing.T) {
cwd, err := os.Getwd()
panicIfErr(err)
bindir := filepath.Join(cwd, "testdata", "external", "bin-name")
tmp := tmpenv.New("PATH")
defer tmp.Restore()
panicIfErr(os.Setenv("PATH", os.Getenv("PATH")+string(os.PathListSeparator)+bindir))
for _, name := range []string{
"foo", "foo-bar", "foo_bar", "-", "_", "-foo", "bar_",
} {
args := []string{"--foo", "xxx", "-b"}
c, ok := NewExternalCmd(fmt.Errorf(`expected command but got "%s"`, name), args)
if !ok {
t.Fatal("subcommand was not extracted", name)
}
want := "notes-" + name
if runtime.GOOS == "windows" {
want += ".bat"
}
if have := filepath.Base(c.ExePath); have != want {
t.Fatal("Wanted command name", want, "but have", have)
}
if !reflect.DeepEqual(args, c.Args) {
t.Fatal("Passed args are unexpected:", c.Args)
}
if !strings.HasSuffix(c.NotesPath, os.Args[0]) {
t.Fatal("`notes` full path is unexpected:", c.NotesPath, "wanted full path of", os.Args[0])
}
}
}
func TestNewExternalCmdSubcmdNotFound(t *testing.T) {
for _, tc := range []struct {
what string
msg string
}{
{
what: "subcommand is not contained in parse error message",
msg: "unknown long flag '--foo'",
},
{
what: "unknown subcommand",
msg: `expected command but got "unknown-subcommand-specified"`,
},
{
what: "invalid subcommand name",
msg: `expected command but got "./foo"`,
},
} {
t.Run(tc.what, func(t *testing.T) {
c, ok := NewExternalCmd(errors.New(tc.msg), []string{})
if ok {
t.Fatalf("Error did not occur: %#v", c)
}
})
}
}
func TestRunExternalCommandOK(t *testing.T) {
bindir := testExternalCommandBinaryDir("test", t)
tmp := tmpenv.New("PATH")
defer tmp.Restore()
panicIfErr(os.Setenv("PATH", os.Getenv("PATH")+string(os.PathListSeparator)+bindir))
args := []string{"-A", "external-test", "--foo", "xxx", "-b"}
cmd, ok := NewExternalCmd(errors.New(`expected command but got "external-test"`), args)
if !ok {
t.Fatal("Subcommand was not found")
}
fake := fakeio.Stdout().Stderr()
defer fake.Restore()
if err := cmd.Do(); err != nil {
t.Fatal(err)
}
out, err := fake.String()
panicIfErr(err)
if !strings.Contains(out, "Output from stdout") {
t.Fatal("Output to stdout is unexpected:", out)
}
if !strings.Contains(out, "Output from stderr") {
t.Fatal("Output to stderr is unexpected:", out)
}
// First argument is a executable path of `notes`. Ignore it by strings.HasSuffix()
want := fmt.Sprintln(append([]string{os.Args[0]}, args...))
if !strings.Contains(out, want) {
t.Fatal("Passed arguments to external command is unexpected. Wanted", want, "in output but have output", out)
}
}
func TestRunExternalCommandExitFailure(t *testing.T) {
bindir := testExternalCommandBinaryDir("error", t)
tmp := tmpenv.New("PATH")
defer tmp.Restore()
panicIfErr(os.Setenv("PATH", os.Getenv("PATH")+string(os.PathListSeparator)+bindir))
cmd, ok := NewExternalCmd(errors.New(`expected command but got "external-error"`), []string{})
if !ok {
t.Fatal("Subcommand was not found")
}
err := cmd.Do()
if err == nil {
t.Fatal("Error did not occur")
}
exe := "notes-external-error"
if runtime.GOOS == "windows" {
exe += ".exe"
}
want := fmt.Sprintf("External command '%s' did not exit successfully", exe)
if !strings.Contains(err.Error(), want) {
t.Fatal("Unexpected error:", err)
}
}