mediocre-go-lib/mcfg/cli_test.go

202 lines
4.5 KiB
Go
Raw Normal View History

package mcfg
import (
"bytes"
"encoding/json"
"fmt"
"log"
"strings"
. "testing"
"time"
"github.com/mediocregopher/mediocre-go-lib/mrand"
"github.com/mediocregopher/mediocre-go-lib/mtest"
"github.com/mediocregopher/mediocre-go-lib/mtest/massert"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSourceCLIHelp(t *T) {
cfg := New()
cfg.ParamInt("foo", 5, "Test int param")
cfg.ParamBool("bar", "Test bool param")
cfg.ParamString("baz", "baz", "Test string param")
cfg.ParamString("baz2", "", "")
src := SourceCLI{}
buf := new(bytes.Buffer)
pvM, err := src.cliParamVals(cfg)
require.NoError(t, err)
SourceCLI{}.printHelp(buf, pvM)
exp := `
--bar (Flag)
Test bool param
--baz (Default: "baz")
Test string param
--baz2
--foo (Default: 5)
Test int param
`
assert.Equal(t, exp, buf.String())
}
type testCLIState struct {
cfg *Cfg
availCfgs []*Cfg
SourceCLI
expPVs []ParamValue
}
type testCLIApplyer struct {
name string
availCfgI int // not technically needed, but makes subsequent steps easier
path []string
isBool bool
nonBoolType string // "int", "str", "duration", "json"
unset bool
nonBoolWEq bool // use equal sign when setting value
nonBoolVal string
}
func (tca testCLIApplyer) Apply(ss mtest.State) (mtest.State, error) {
s := ss.(testCLIState)
// the tca needs to get added to its cfg as a Param
thisCfg := s.availCfgs[tca.availCfgI]
p := Param{
Name: tca.name,
IsString: tca.nonBoolType == "str" || tca.nonBoolType == "duration",
IsBool: tca.isBool,
// the cli parser doesn't actually care about the other fields of Param,
// those are only used by Cfg once it has all ParamValues together
}
thisCfg.ParamAdd(p)
// if the arg is set then add it to the cli args and the expected output pvs
if !tca.unset {
arg := cliKeyPrefix
if len(tca.path) > 0 {
arg += strings.Join(tca.path, cliKeyJoin) + cliKeyJoin
}
arg += tca.name
if !tca.isBool {
if tca.nonBoolWEq {
arg += "="
} else {
s.SourceCLI.Args = append(s.SourceCLI.Args, arg)
arg = ""
}
arg += tca.nonBoolVal
}
s.SourceCLI.Args = append(s.SourceCLI.Args, arg)
log.Print(strings.Join(s.SourceCLI.Args, " "))
pv := ParamValue{
Param: p,
Path: tca.path,
}
if tca.isBool {
pv.Value = json.RawMessage("true")
} else {
switch tca.nonBoolType {
case "str", "duration":
pv.Value = json.RawMessage(fmt.Sprintf("%q", tca.nonBoolVal))
case "int", "json":
pv.Value = json.RawMessage(tca.nonBoolVal)
default:
panic("shouldn't get here")
}
}
s.expPVs = append(s.expPVs, pv)
}
// and finally the state needs to be checked
gotPVs, err := s.SourceCLI.Parse(s.cfg)
if err != nil {
return nil, err
}
return s, massert.All(
massert.Len(gotPVs, len(s.expPVs)),
massert.Subset(s.expPVs, gotPVs),
).Assert()
}
func TestSourceCLI(t *T) {
chk := mtest.Checker{
Init: func() mtest.State {
var s testCLIState
s.cfg = New()
{
a := s.cfg.Child("a")
b := s.cfg.Child("b")
c := s.cfg.Child("c")
ab := a.Child("b")
bc := b.Child("c")
abc := ab.Child("c")
s.availCfgs = []*Cfg{s.cfg, a, b, c, ab, bc, abc}
}
s.SourceCLI.Args = make([]string, 0, 16)
return s
},
Actions: func(ss mtest.State) []mtest.Action {
s := ss.(testCLIState)
var tca testCLIApplyer
if i := mrand.Intn(8); i == 0 {
tca.name = mrand.Hex(1) + "-" + mrand.Hex(8)
} else if i == 1 {
tca.name = mrand.Hex(1) + "=" + mrand.Hex(8)
} else {
tca.name = mrand.Hex(8)
}
tca.availCfgI = mrand.Intn(len(s.availCfgs))
thisCfg := s.availCfgs[tca.availCfgI]
tca.path = thisCfg.Path
tca.isBool = mrand.Intn(2) == 0
if !tca.isBool {
tca.nonBoolType = mrand.Element([]string{
"int",
"str",
"duration",
"json",
}, nil).(string)
}
tca.unset = mrand.Intn(10) == 0
if tca.isBool || tca.unset {
return []mtest.Action{{Applyer: tca}}
}
tca.nonBoolWEq = mrand.Intn(2) == 0
switch tca.nonBoolType {
case "int":
tca.nonBoolVal = fmt.Sprint(mrand.Int())
case "str":
tca.nonBoolVal = mrand.Hex(16)
case "duration":
dur := time.Duration(mrand.Intn(86400)) * time.Second
tca.nonBoolVal = dur.String()
case "json":
b, _ := json.Marshal(map[string]int{
mrand.Hex(4): mrand.Int(),
mrand.Hex(4): mrand.Int(),
mrand.Hex(4): mrand.Int(),
})
tca.nonBoolVal = string(b)
}
return []mtest.Action{{Applyer: tca}}
},
}
if err := chk.RunUntil(5 * time.Second); err != nil {
t.Fatal(err)
}
}