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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
package pflag
import (
"errors"
"flag"
"io"
"strings"
"testing"
)
func cmpLists(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i := range a {
if a[i] != b[i] {
return false
}
}
return true
}
func TestFunc(t *testing.T) {
var values []string
fn := func(s string) error {
values = append(values, s)
return nil
}
fset := NewFlagSet("test", ContinueOnError)
fset.Func("fnflag", "Callback function", fn)
err := fset.Parse([]string{"--fnflag=aa", "--fnflag", "bb"})
if err != nil {
t.Fatal("expected no error; got", err)
}
expected := []string{"aa", "bb"}
if !cmpLists(expected, values) {
t.Fatalf("expected %v, got %v", expected, values)
}
}
func TestFuncP(t *testing.T) {
var values []string
fn := func(s string) error {
values = append(values, s)
return nil
}
fset := NewFlagSet("test", ContinueOnError)
fset.FuncP("fnflag", "f", "Callback function", fn)
err := fset.Parse([]string{"--fnflag=a", "--fnflag", "b", "-fc", "-f=d", "-f", "e"})
if err != nil {
t.Fatal("expected no error; got", err)
}
expected := []string{"a", "b", "c", "d", "e"}
if !cmpLists(expected, values) {
t.Fatalf("expected %v, got %v", expected, values)
}
}
func TestFuncCompat(t *testing.T) {
// compare behavior with the stdlib 'flag' package
type FuncFlagSet interface {
Func(name string, usage string, fn func(string) error)
Parse([]string) error
}
unitTestErr := errors.New("unit test error")
runCase := func(f FuncFlagSet, name string, args []string) (values []string, err error) {
fn := func(s string) error {
values = append(values, s)
if s == "err" {
return unitTestErr
}
return nil
}
f.Func(name, "Callback function", fn)
err = f.Parse(args)
return values, err
}
t.Run("regular parsing", func(t *testing.T) {
flagName := "fnflag"
args := []string{"--fnflag=xx", "--fnflag", "yy", "--fnflag=zz"}
stdFSet := flag.NewFlagSet("std test", flag.ContinueOnError)
stdValues, err := runCase(stdFSet, flagName, args)
if err != nil {
t.Fatalf("std flag: expected no error, got %v", err)
}
expected := []string{"xx", "yy", "zz"}
if !cmpLists(expected, stdValues) {
t.Fatalf("std flag: expected %v, got %v", expected, stdValues)
}
fset := NewFlagSet("pflag test", ContinueOnError)
pflagValues, err := runCase(fset, flagName, args)
if err != nil {
t.Fatalf("pflag: expected no error, got %v", err)
}
if !cmpLists(stdValues, pflagValues) {
t.Fatalf("pflag: expected %v, got %v", stdValues, pflagValues)
}
})
t.Run("error triggered by callback", func(t *testing.T) {
flagName := "fnflag"
args := []string{"--fnflag", "before", "--fnflag", "err", "--fnflag", "after"}
// test behavior of standard flag.Fset with an error triggered by the callback:
// (note: as can be seen in 'runCase()', if the callback sees "err" as a value
// for the flag, it will return an error)
stdFSet := flag.NewFlagSet("std test", flag.ContinueOnError)
stdFSet.SetOutput(io.Discard) // suppress output
// run test case with standard flag.Fset
stdValues, err := runCase(stdFSet, flagName, args)
// double check the standard behavior:
// - .Parse() should return an error, which contains the error message
if err == nil {
t.Fatalf("std flag: expected an error triggered by callback, got no error instead")
}
if !strings.HasSuffix(err.Error(), unitTestErr.Error()) {
t.Fatalf("std flag: expected unittest error, got unexpected error value: %T %v", err, err)
}
// - the function should have been called twice, with the first two values,
// the final "=after" should not be recorded
expected := []string{"before", "err"}
if !cmpLists(expected, stdValues) {
t.Fatalf("std flag: expected %v, got %v", expected, stdValues)
}
// now run the test case on a pflag FlagSet:
fset := NewFlagSet("pflag test", ContinueOnError)
pflagValues, err := runCase(fset, flagName, args)
// check that there is a similar error (note: pflag will _wrap_ the error, while the stdlib
// currently keeps the original message but creates a flat errors.Error)
if !errors.Is(err, unitTestErr) {
t.Fatalf("pflag: got unexpected error value: %T %v", err, err)
}
// the callback should be called the same number of times, with the same values:
if !cmpLists(stdValues, pflagValues) {
t.Fatalf("pflag: expected %v, got %v", stdValues, pflagValues)
}
})
}
func TestFuncUsage(t *testing.T) {
t.Run("regular func flag", func(t *testing.T) {
// regular func flag:
// expect to see '--flag1 value' followed by the usageMessage, and no mention of a default value
fset := NewFlagSet("unittest", ContinueOnError)
fset.Func("flag1", "usage message", func(s string) error { return nil })
usage := fset.FlagUsagesWrapped(80)
usage = strings.TrimSpace(usage)
expected := "--flag1 value usage message"
if usage != expected {
t.Fatalf("unexpected generated usage message\n expected: %s\n got: %s", expected, usage)
}
})
t.Run("func flag with placeholder name", func(t *testing.T) {
// func flag, with a placeholder name:
// if usageMesage contains a placeholder, expect that name; still expect no mention of a default value
fset := NewFlagSet("unittest", ContinueOnError)
fset.Func("flag2", "usage message with `name` placeholder", func(s string) error { return nil })
usage := fset.FlagUsagesWrapped(80)
usage = strings.TrimSpace(usage)
expected := "--flag2 name usage message with name placeholder"
if usage != expected {
t.Fatalf("unexpected generated usage message\n expected: %s\n got: %s", expected, usage)
}
})
}
|
