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
|
// Copyright 2020 Harald Albrecht.
//
// 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 enumflag
import (
"github.com/spf13/cobra"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
)
var _ = Describe("flag", func() {
Context("scalar enum flag", func() {
It("returns the canonical textual representation", func() {
foomode := fmBar
val := New(&foomode, "mode", FooModeIdentifiersTest, EnumCaseInsensitive)
Expect(val.String()).To(Equal("bar"))
Expect(val.Type()).To(Equal("mode"))
})
It("rejects setting invalid values", func() {
var foomode FooModeTest
val := New(&foomode, "mode", FooModeIdentifiersTest, EnumCaseSensitive)
Expect(val.Set("FOOBAR")).To(MatchError("must be 'bar'/'Bar', 'baz', 'foo'"))
})
It("sets the enumeration value from text", func() {
var foomode FooModeTest
val := New(&foomode, "mode", FooModeIdentifiersTest, EnumCaseSensitive)
Expect(val.Set("foo")).NotTo(HaveOccurred())
Expect(val.Set("Bar")).NotTo(HaveOccurred())
Expect(foomode).To(Equal(fmBar))
Expect(val.Get()).To(Equal(fmBar))
})
})
Context("slice enum flag", func() {
It("returns the canonical textual representation", func() {
foomodes := []FooModeTest{fmBar, fmFoo}
val := NewSlice(&foomodes, "modes", FooModeIdentifiersTest, EnumCaseInsensitive)
Expect(val.String()).To(Equal("[bar,foo]"))
Expect(val.Type()).To(Equal("modes"))
})
})
Context("retrieving the enum value", func() {
It("succeeds for scalar", func() {
var foomode = fmBar
val := New(&foomode, "mode", FooModeIdentifiersTest, EnumCaseSensitive)
Expect(val.GetValue()).To(Equal(fmBar))
Expect(val.GetSliceValue()).To(BeZero())
})
It("succeeds for slices", func() {
var foomodes = []FooModeTest{fmBar}
val := NewSlice(&foomodes, "mode", FooModeIdentifiersTest, EnumCaseSensitive)
Expect(val.GetValue()).To(BeZero())
Expect(val.GetSliceValue()).To(ConsistOf(fmBar))
})
})
When("passing nil", func() {
It("panics", func() {
Expect(func() {
_ = New[FooModeTest](nil, "foo", nil, EnumCaseInsensitive)
}).To(PanicWith(MatchRegexp("New requires flag to be a non-nil pointer to .*")))
Expect(func() {
var f FooModeTest
_ = New(&f, "foo", nil, EnumCaseInsensitive)
}).To(PanicWith(MatchRegexp("New requires mapping not to be nil")))
Expect(func() {
_ = NewSlice[FooModeTest](nil, "foo", nil, EnumCaseInsensitive)
}).To(PanicWith(MatchRegexp("NewSlice requires flag to be a non-nil pointer to .*")))
Expect(func() {
var f []FooModeTest
_ = NewSlice(&f, "foo", nil, EnumCaseInsensitive)
}).To(PanicWith(MatchRegexp("NewSlice requires mapping not to be nil")))
})
})
It("returns completors", func() {
cmd := &cobra.Command{}
foomodes := []FooModeTest{fmBar, fmFoo}
val := NewSlice(&foomodes, "modes", FooModeIdentifiersTest, EnumCaseInsensitive)
cmd.PersistentFlags().Var(val, "mode", "blahblah")
Expect(val.RegisterCompletion(cmd, "mode", Help[FooModeTest]{
fmFoo: "gives a foo",
fmBar: "gives a bar",
fmBaz: "gives a baz",
})).To(Succeed())
})
})
|
