145 lines
3.0 KiB
Go
145 lines
3.0 KiB
Go
package mcfg
|
|
|
|
import (
|
|
"context"
|
|
. "testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestHook(t *T) {
|
|
{ // test Then
|
|
aCh := make(chan bool)
|
|
bCh := make(chan bool)
|
|
h := Nop()
|
|
h.Then(func(context.Context) error {
|
|
aCh <- true
|
|
<-aCh
|
|
return nil
|
|
})
|
|
h.Then(func(context.Context) error {
|
|
bCh <- true
|
|
<-bCh
|
|
return nil
|
|
})
|
|
errCh := make(chan error)
|
|
go func() {
|
|
errCh <- h(context.Background())
|
|
}()
|
|
|
|
assert.True(t, <-aCh)
|
|
// make sure bCh isn't being written to till aCh is closed
|
|
select {
|
|
case <-bCh:
|
|
assert.Fail(t, "bCh shouldn't be written to yet")
|
|
case <-time.After(250 * time.Millisecond):
|
|
close(aCh)
|
|
}
|
|
assert.True(t, <-bCh)
|
|
// make sure errCh isn't being written to till bCh is closed
|
|
select {
|
|
case <-errCh:
|
|
assert.Fail(t, "errCh shouldn't be written to yet")
|
|
case <-time.After(250 * time.Millisecond):
|
|
close(bCh)
|
|
}
|
|
assert.Nil(t, <-errCh)
|
|
}
|
|
|
|
{ // test Also
|
|
aCh := make(chan bool)
|
|
bCh := make(chan bool)
|
|
h := Nop()
|
|
h.Also(func(context.Context) error {
|
|
aCh <- true
|
|
<-aCh
|
|
return nil
|
|
})
|
|
h.Also(func(context.Context) error {
|
|
bCh <- true
|
|
<-bCh
|
|
return nil
|
|
})
|
|
errCh := make(chan error)
|
|
go func() {
|
|
errCh <- h(context.Background())
|
|
}()
|
|
|
|
// both channels should get written to, then closed, then errCh should
|
|
// get written to
|
|
assert.True(t, <-aCh)
|
|
assert.True(t, <-bCh)
|
|
// make sure errCh isn't being written to till both channels are written
|
|
select {
|
|
case <-errCh:
|
|
assert.Fail(t, "errCh shouldn't be written to yet")
|
|
case <-time.After(250 * time.Millisecond):
|
|
close(aCh)
|
|
close(bCh)
|
|
}
|
|
assert.Nil(t, <-errCh)
|
|
}
|
|
}
|
|
|
|
func TestPopulateParams(t *T) {
|
|
{
|
|
cfg := New()
|
|
a := cfg.ParamInt("a", 0, "")
|
|
cfgChild := cfg.Child("foo")
|
|
b := cfgChild.ParamInt("b", 0, "")
|
|
c := cfgChild.ParamInt("c", 0, "")
|
|
|
|
err := cfg.populateParams(SourceCLI{
|
|
Args: []string{"--a=1", "--foo-b=2"},
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 1, *a)
|
|
assert.Equal(t, 2, *b)
|
|
assert.Equal(t, 0, *c)
|
|
}
|
|
|
|
{ // test that required params are enforced
|
|
cfg := New()
|
|
a := cfg.ParamInt("a", 0, "")
|
|
cfgChild := cfg.Child("foo")
|
|
b := cfgChild.ParamInt("b", 0, "")
|
|
c := cfgChild.ParamRequiredInt("c", "")
|
|
|
|
err := cfg.populateParams(SourceCLI{
|
|
Args: []string{"--a=1", "--foo-b=2"},
|
|
})
|
|
assert.Error(t, err)
|
|
|
|
err = cfg.populateParams(SourceCLI{
|
|
Args: []string{"--a=1", "--foo-b=2", "--foo-c=3"},
|
|
})
|
|
assert.NoError(t, err)
|
|
assert.Equal(t, 1, *a)
|
|
assert.Equal(t, 2, *b)
|
|
assert.Equal(t, 3, *c)
|
|
}
|
|
}
|
|
|
|
func TestChild(t *T) {
|
|
cfg := New()
|
|
assert.True(t, cfg.IsRoot())
|
|
assert.Equal(t, "", cfg.Name())
|
|
assert.Equal(t, "/", cfg.FullName())
|
|
|
|
foo := cfg.Child("foo")
|
|
assert.False(t, foo.IsRoot())
|
|
assert.Equal(t, "foo", foo.Name())
|
|
assert.Equal(t, "/foo", foo.FullName())
|
|
|
|
bar := cfg.Child("bar")
|
|
assert.False(t, bar.IsRoot())
|
|
assert.Equal(t, "bar", bar.Name())
|
|
assert.Equal(t, "/bar", bar.FullName())
|
|
|
|
foo2 := foo.Child("foo2")
|
|
assert.False(t, foo2.IsRoot())
|
|
assert.Equal(t, "foo2", foo2.Name())
|
|
assert.Equal(t, "/foo/foo2", foo2.FullName())
|
|
}
|