-
Notifications
You must be signed in to change notification settings - Fork 1.8k
Expand file tree
/
Copy pathcompletion_partial_regression_test.go
More file actions
121 lines (115 loc) · 3.8 KB
/
Copy pathcompletion_partial_regression_test.go
File metadata and controls
121 lines (115 loc) · 3.8 KB
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
package cli
import (
"bytes"
"context"
"os"
"reflect"
"strings"
"testing"
)
func partialCompletionCommand(output *bytes.Buffer, ran *bool) *Command {
command := func(name string) *Command {
return &Command{
Name: name,
Flags: []Flag{
&StringFlag{Name: "param-" + name + "-one"},
&StringFlag{Name: "param-" + name + "-two"},
&StringFlag{Name: "param-" + name + "-hidden", Hidden: true},
&BoolFlag{Name: "unrelated-" + name},
},
Action: func(context.Context, *Command) error { *ran = true; return nil },
}
}
root, child, nested := command("app"), command("sub"), command("nested")
root.Writer, root.ErrWriter = output, output
root.EnableShellCompletion = true
root.Commands = []*Command{child}
child.Commands = []*Command{nested}
return root
}
func TestPartialFlagCompletionAfterPositionalArgument(t *testing.T) {
originalArgs := os.Args
t.Cleanup(func() { os.Args = originalArgs })
for _, scope := range []struct {
name string
path []string
want string
}{
{"app", nil, "--param-app-one\n--param-app-two\n"},
{"sub", []string{"sub"}, "--param-sub-one\n--param-sub-two\n--param-app-one\n--param-app-two\n"},
{"nested", []string{"sub", "nested"}, "--param-nested-one\n--param-nested-two\n--param-app-one\n--param-app-two\n--param-sub-one\n--param-sub-two\n"},
} {
for _, positional := range [][]string{nil, {"value"}, {"first", "second"}} {
t.Run(scope.name+"/"+strings.Join(positional, "_"), func(t *testing.T) {
var output bytes.Buffer
ran := false
cmd := partialCompletionCommand(&output, &ran)
args := append([]string{"app"}, scope.path...)
args = append(args, positional...)
args = append(args, "--pa", completionFlag)
os.Args = args
if err := cmd.Run(context.Background(), args); err != nil {
t.Fatal(err)
}
if got := output.String(); got != scope.want {
t.Errorf("completion for %q = %q, want %q", args, got, scope.want)
}
if ran {
t.Error("completion executed the command action")
}
})
}
}
}
func TestPartialFlagCompletionAfterDoubleDash(t *testing.T) {
originalArgs := os.Args
t.Cleanup(func() { os.Args = originalArgs })
for _, path := range [][]string{nil, {"sub"}, {"sub", "nested"}} {
t.Run(strings.Join(path, "/"), func(t *testing.T) {
var output bytes.Buffer
ran := false
cmd := partialCompletionCommand(&output, &ran)
args := append([]string{"app"}, path...)
args = append(args, "--", "--pa", completionFlag)
os.Args = args
if err := cmd.Run(context.Background(), args); err != nil {
t.Fatal(err)
}
if output.Len() != 0 || ran {
t.Errorf("completion after --: output=%q action=%v", output.String(), ran)
}
})
}
}
func TestPartialFlagCustomCompletionArgs(t *testing.T) {
var output bytes.Buffer
ran := false
cmd := partialCompletionCommand(&output, &ran)
var got []string
cmd.Commands[0].ShellComplete = func(_ context.Context, cmd *Command) {
got = append([]string(nil), cmd.Args().Slice()...)
}
args := []string{"app", "sub", "value", "--pa", completionFlag}
if err := cmd.Run(context.Background(), args); err != nil {
t.Fatal(err)
}
if want := []string{"value", "--pa"}; !reflect.DeepEqual(got, want) {
t.Errorf("custom completion args = %q, want %q", got, want)
}
if ran {
t.Error("custom completion executed the action")
}
}
func TestPartialFlagCompletionDisabled(t *testing.T) {
var output bytes.Buffer
ran := false
cmd := partialCompletionCommand(&output, &ran)
cmd.EnableShellCompletion = false
args := []string{"app", "sub", "value", "--pa", completionFlag}
if err := cmd.Run(context.Background(), args); err == nil {
t.Fatal("disabled completion accepted an undefined flag")
}
if ran || strings.Contains(output.String(), "--param-sub-one\n--param-sub-two\n") {
t.Fatalf("disabled completion: output=%q action=%v", output.String(), ran)
}
}