dualfroz
cb6b9f9456
GetValue and Exists validated only the upper bound of a numeric key-path segment, so a negative index such as "arr.-1" passed the check and indexed the slice with -1, causing an index-out-of-range panic. Add a lower-bound check (i < 0) to the []int, []string and []any cases in both functions.
523 lines
9.8 KiB
Go
523 lines
9.8 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gookit/goutil/testutil"
|
|
"github.com/gookit/goutil/testutil/assert"
|
|
)
|
|
|
|
func TestConfig_GetValue(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
ClearAll()
|
|
err := LoadStrings(JSON, jsonStr)
|
|
is.Nil(err)
|
|
|
|
c := Default()
|
|
|
|
// error on get
|
|
_, ok := GetValue("")
|
|
is.False(ok)
|
|
|
|
_, ok = c.GetValue("notExist")
|
|
is.False(ok)
|
|
_, ok = c.GetValue("name.sub")
|
|
is.False(ok)
|
|
is.Err(c.Error())
|
|
|
|
_, ok = c.GetValue("map1.key", false)
|
|
is.False(ok)
|
|
is.False(Exists("map1.key", false))
|
|
|
|
val, ok := GetValue("map1.notExist")
|
|
is.Nil(val)
|
|
is.False(ok)
|
|
is.False(Exists("map1.notExist"))
|
|
|
|
val, ok = GetValue("notExist.sub")
|
|
is.False(ok)
|
|
is.Nil(val)
|
|
is.False(Exists("notExist.sub"))
|
|
|
|
val, ok = c.GetValue("arr1.100")
|
|
is.Nil(val)
|
|
is.False(ok)
|
|
is.False(Exists("arr1.100"))
|
|
|
|
val, ok = c.GetValue("arr1.notExist")
|
|
is.Nil(val)
|
|
is.False(ok)
|
|
is.False(Exists("arr1.notExist"))
|
|
|
|
// load data for tests
|
|
err = c.LoadData(map[string]any{
|
|
"setStrMap": map[string]string{
|
|
"k": "v",
|
|
},
|
|
"setIntMap": map[string]int{
|
|
"k2": 23,
|
|
},
|
|
})
|
|
is.Nil(err)
|
|
// -- assert map[string]string
|
|
is.True(Exists("setStrMap.k"))
|
|
is.Eq("v", Get("setStrMap.k"))
|
|
is.False(Exists("setStrMap.k1"))
|
|
|
|
// -- assert map[string]int
|
|
is.True(Exists("setIntMap.k2"))
|
|
is.Eq(23, Get("setIntMap.k2"))
|
|
is.False(Exists("setIntMap.k1"))
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestGet(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
ClearAll()
|
|
err := LoadStrings(JSON, jsonStr)
|
|
is.Nil(err)
|
|
|
|
// fmt.Printf("%#v\n", Data())
|
|
c := Default()
|
|
|
|
is.False(c.IsEmpty())
|
|
is.True(Exists("age"))
|
|
is.True(Exists("map1.key"))
|
|
is.True(Exists("arr1.1"))
|
|
is.False(Exists("arr1.1", false))
|
|
is.False(Exists("not-exist.sub"))
|
|
is.False(Exists(""))
|
|
is.False(Exists("not-exist"))
|
|
|
|
// get value
|
|
val := Get("age")
|
|
is.Eq(float64(123), val)
|
|
is.Eq("float64", fmt.Sprintf("%T", val))
|
|
|
|
val = Get("not-exist")
|
|
is.Nil(val)
|
|
|
|
val = Get("name")
|
|
is.Eq("app", val)
|
|
|
|
is.Eq([]string{"php", "go"}, StringsBySplit("tagsStr", ","))
|
|
|
|
// get string array
|
|
arr := Strings("notExist")
|
|
is.Empty(arr)
|
|
|
|
arr = Strings("map1")
|
|
is.Empty(arr)
|
|
|
|
arr = Strings("arr1")
|
|
is.Eq(`[]string{"val", "val1", "val2"}`, fmt.Sprintf("%#v", arr))
|
|
|
|
val = String("arr1.1")
|
|
is.Eq("val1", val)
|
|
|
|
err = LoadStrings(JSON, `{
|
|
"iArr": [12, 34, 36],
|
|
"iMap": {"k1": 12, "k2": 34, "k3": 36}
|
|
}`)
|
|
is.Nil(err)
|
|
|
|
// Ints: get int arr
|
|
iarr := Ints("name")
|
|
is.False(Exists("name.1"))
|
|
is.Empty(iarr)
|
|
|
|
iarr = Ints("notExist")
|
|
is.Empty(iarr)
|
|
|
|
iarr = Ints("iArr")
|
|
is.Eq(`[]int{12, 34, 36}`, fmt.Sprintf("%#v", iarr))
|
|
|
|
iv := Int("iArr.1")
|
|
is.Eq(34, iv)
|
|
|
|
iv = Int("iArr.100")
|
|
is.Eq(0, iv)
|
|
|
|
// IntMap: get int map
|
|
imp := IntMap("name")
|
|
is.Empty(imp)
|
|
imp = IntMap("notExist")
|
|
is.Empty(imp)
|
|
|
|
imp = IntMap("iMap")
|
|
is.NotEmpty(imp)
|
|
|
|
iv = Int("iMap.k2")
|
|
is.Eq(34, iv)
|
|
is.True(Exists("iMap.k2"))
|
|
|
|
iv = Int("iMap.notExist")
|
|
is.Eq(0, iv)
|
|
is.False(Exists("iMap.notExist"))
|
|
|
|
// set a intMap
|
|
err = Set("intMap0", map[string]int{"a": 1, "b": 2})
|
|
is.Nil(err)
|
|
|
|
imp = IntMap("intMap0")
|
|
is.NotEmpty(imp)
|
|
is.Eq(1, imp["a"])
|
|
is.Eq(2, Get("intMap0.b"))
|
|
is.True(Exists("intMap0.a"))
|
|
is.False(Exists("intMap0.c"))
|
|
|
|
// StringMap: get string map
|
|
smp := StringMap("map1")
|
|
is.Eq("val1", smp["key1"])
|
|
|
|
// like load from yaml content
|
|
// c = New("test")
|
|
err = c.LoadData(map[string]any{
|
|
"newIArr": []int{2, 3},
|
|
"newSArr": []string{"a", "b"},
|
|
"newIArr1": []any{12, 23},
|
|
"newIArr2": []any{12, "abc"},
|
|
"invalidMap": map[string]int{"k": 1},
|
|
"yMap": map[any]any{
|
|
"k0": "v0",
|
|
"k1": 23,
|
|
},
|
|
"yMap1": map[any]any{
|
|
"k": "v",
|
|
"k1": 23,
|
|
"k2": []any{23, 45},
|
|
},
|
|
"yMap10": map[string]any{
|
|
"k": "v",
|
|
"k1": 23,
|
|
"k2": []any{23, 45},
|
|
},
|
|
"yMap2": map[any]any{
|
|
"k": 2,
|
|
"k1": 23,
|
|
},
|
|
"yArr": []any{23, 45, "val", map[string]any{"k4": "v4"}},
|
|
})
|
|
is.Nil(err)
|
|
|
|
iarr = Ints("newIArr")
|
|
is.Eq("[2 3]", fmt.Sprintf("%v", iarr))
|
|
|
|
iarr = Ints("newIArr1")
|
|
is.Eq("[12 23]", fmt.Sprintf("%v", iarr))
|
|
iarr = Ints("newIArr2")
|
|
is.Empty(iarr)
|
|
|
|
iv = Int("newIArr.1")
|
|
is.True(Exists("newIArr.1"))
|
|
is.Eq(3, iv)
|
|
|
|
iv = Int("newIArr.200")
|
|
is.False(Exists("newIArr.200"))
|
|
is.Eq(0, iv)
|
|
|
|
// invalid intMap
|
|
imp = IntMap("yMap1")
|
|
is.Empty(imp)
|
|
|
|
imp = IntMap("yMap10")
|
|
is.Empty(imp)
|
|
|
|
imp = IntMap("yMap2")
|
|
is.Eq(2, imp["k"])
|
|
|
|
val = String("newSArr.1")
|
|
is.True(Exists("newSArr.1"))
|
|
is.Eq("b", val)
|
|
|
|
val = String("newSArr.100")
|
|
is.False(Exists("newSArr.100"))
|
|
is.Eq("", val)
|
|
|
|
smp = StringMap("invalidMap")
|
|
is.Nil(smp)
|
|
|
|
smp = StringMap("yMap.notExist")
|
|
is.Nil(smp)
|
|
|
|
smp = StringMap("yMap")
|
|
is.True(Exists("yMap.k0"))
|
|
is.False(Exists("yMap.k100"))
|
|
is.Eq("v0", smp["k0"])
|
|
|
|
iarr = Ints("yMap1.k2")
|
|
is.Eq("[23 45]", fmt.Sprintf("%v", iarr))
|
|
}
|
|
|
|
func TestInt(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadStrings(JSON, jsonStr)
|
|
|
|
is.True(Exists("age"))
|
|
|
|
iv := Int("age")
|
|
is.Eq(123, iv)
|
|
|
|
iv = Int("name")
|
|
is.Eq(0, iv)
|
|
|
|
iv = Int("notExist", 34)
|
|
is.Eq(34, iv)
|
|
|
|
c := Default()
|
|
iv = c.Int("age")
|
|
is.Eq(123, iv)
|
|
iv = c.Int("notExist")
|
|
is.Eq(0, iv)
|
|
|
|
uiv := Uint("age")
|
|
is.Eq(uint(123), uiv)
|
|
|
|
dur := Duration("age")
|
|
is.Eq(time.Duration(123), dur)
|
|
is.Eq(time.Duration(340), Duration("not-exist", 340))
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestInt64(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadStrings(JSON, jsonStr)
|
|
|
|
// get int64
|
|
iv64 := Int64("age")
|
|
is.Eq(int64(123), iv64)
|
|
|
|
iv64 = Int64("name")
|
|
is.Eq(iv64, int64(0))
|
|
|
|
iv64 = Int64("age", 34)
|
|
is.Eq(int64(123), iv64)
|
|
iv64 = Int64("notExist", 34)
|
|
is.Eq(int64(34), iv64)
|
|
|
|
c := Default()
|
|
iv64 = c.Int64("age")
|
|
is.Eq(int64(123), iv64)
|
|
iv64 = c.Int64("notExist")
|
|
is.Eq(int64(0), iv64)
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestFloat(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadStrings(JSON, jsonStr)
|
|
c := Default()
|
|
|
|
// get float
|
|
err := c.Set("flVal", 23.45)
|
|
is.Nil(err)
|
|
flt := c.Float("flVal")
|
|
is.Eq(23.45, flt)
|
|
|
|
flt = Float("name")
|
|
is.Eq(float64(0), flt)
|
|
|
|
flt = c.Float("notExists")
|
|
is.Eq(float64(0), flt)
|
|
|
|
flt = c.Float("notExists", 10)
|
|
is.Eq(float64(10), flt)
|
|
|
|
flt = Float("flVal", 0)
|
|
is.Eq(23.45, flt)
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestString(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadStrings(JSON, jsonStr)
|
|
|
|
// get string
|
|
val := String("arr1")
|
|
is.Eq("[val val1 val2]", val)
|
|
|
|
str := String("notExists")
|
|
is.Eq("", str)
|
|
is.Panics(func() {
|
|
MustString("notExists")
|
|
})
|
|
|
|
str = String("notExists", "defVal")
|
|
is.Eq("defVal", str)
|
|
|
|
c := Default()
|
|
str = c.String("name")
|
|
is.Eq("app", str)
|
|
str = c.String("notExist")
|
|
is.Eq("", str)
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestBool(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadSources(JSON, []byte(jsonStr))
|
|
|
|
// get bool
|
|
val := Get("debug")
|
|
is.Eq(true, val)
|
|
|
|
bv := Bool("debug")
|
|
is.Eq(true, bv)
|
|
|
|
bv = Bool("age")
|
|
is.Eq(false, bv)
|
|
|
|
bv = Bool("debug", false)
|
|
is.Eq(true, bv)
|
|
|
|
bv = Bool("notExist", false)
|
|
is.Eq(false, bv)
|
|
|
|
c := Default()
|
|
bv = c.Bool("debug")
|
|
is.True(bv)
|
|
bv = c.Bool("notExist")
|
|
is.False(bv)
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestSubDataMap(t *testing.T) {
|
|
is := assert.New(t)
|
|
ClearAll()
|
|
_ = LoadSources(JSON, []byte(jsonStr))
|
|
|
|
mp := SubDataMap("map1")
|
|
is.NotEmpty(mp)
|
|
is.Eq("230", mp.Get("key4"))
|
|
is.Eq(230, mp.Int("key4"))
|
|
|
|
mp = SubDataMap("notExist")
|
|
is.Empty(mp)
|
|
|
|
ClearAll()
|
|
}
|
|
|
|
func TestParseEnv(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
cfg := NewWithOptions("test", ParseEnv)
|
|
err := cfg.LoadStrings(JSON, `{
|
|
"ekey": "${EnvKey}",
|
|
"ekey0": "${ EnvKey0 }",
|
|
"ekey1": "${EnvKey1|defValue}",
|
|
"ekey2": "${ EnvKey2 | defValue1 }",
|
|
"ekey3": "${ EnvKey3 | app:run }",
|
|
"ekey4": "${FirstEnv}/${ SecondEnv }",
|
|
"ekey5": "${TEST_SHELL|/bin/bash}",
|
|
"ekey6": "${ EnvKey6 | app=run }",
|
|
"ekey7": "${ EnvKey7 | app.run }",
|
|
"ekey8": "${ EnvKey8 | app/run }"
|
|
}`)
|
|
|
|
is.NoErr(err)
|
|
|
|
tests := []struct{ EKey, EVal, CKey, CVal string }{
|
|
{"EnvKey", "EnvKey val", "ekey", "EnvKey val"},
|
|
{"EnvKey", "", "ekey", ""},
|
|
{"EnvKey0", "EnvKey0 val", "ekey0", "EnvKey0 val"},
|
|
{"EnvKey3", "EnvKey3 val", "ekey3", "EnvKey3 val"},
|
|
{"EnvKey3", "", "ekey3", "app:run"},
|
|
{"EnvKey6", "", "ekey6", "app=run"},
|
|
{"EnvKey7", "", "ekey7", "app.run"},
|
|
{"EnvKey8", "", "ekey8", "app/run"},
|
|
{"TEST_SHELL", "/bin/zsh", "ekey5", "/bin/zsh"},
|
|
{"TEST_SHELL", "", "ekey5", "/bin/bash"},
|
|
}
|
|
|
|
for _, smp := range tests {
|
|
is.Eq("", Getenv(smp.EKey))
|
|
|
|
testutil.MockEnvValue(smp.EKey, smp.EVal, func(eVal string) {
|
|
is.Eq(smp.EVal, eVal)
|
|
is.Eq(smp.CVal, cfg.String(smp.CKey))
|
|
})
|
|
}
|
|
|
|
// test multi ENV key
|
|
is.Eq("", Getenv("FirstEnv"))
|
|
|
|
testutil.MockEnvValues(map[string]string{
|
|
"FirstEnv": "abc",
|
|
"SecondEnv": "def",
|
|
}, func() {
|
|
is.Eq("abc", Getenv("FirstEnv"))
|
|
is.Eq("def", Getenv("SecondEnv"))
|
|
is.Eq("abc/def", cfg.String("ekey4"))
|
|
})
|
|
|
|
testutil.MockEnvValues(map[string]string{
|
|
"FirstEnv": "abc",
|
|
}, func() {
|
|
is.Eq("abc", Getenv("FirstEnv"))
|
|
is.Eq("", Getenv("SecondEnv"))
|
|
is.Eq("abc/", cfg.String("ekey4"))
|
|
})
|
|
}
|
|
|
|
func TestConfig_Duration_getter(t *testing.T) {
|
|
is := assert.New(t)
|
|
c := New("test")
|
|
err := c.LoadStrings(JSON, `{
|
|
"ttl": "300s",
|
|
"idle": "1h30m",
|
|
"short": "20m",
|
|
"nanos": 500,
|
|
"bad": "not-a-duration"
|
|
}`)
|
|
is.Nil(err)
|
|
|
|
// Go duration strings are parsed.
|
|
is.Eq(300*time.Second, c.Duration("ttl"))
|
|
is.Eq(90*time.Minute, c.Duration("idle"))
|
|
is.Eq(20*time.Minute, c.Duration("short"))
|
|
|
|
// A bare integer stays nanoseconds (backwards compatible).
|
|
is.Eq(time.Duration(500), c.Duration("nanos"))
|
|
|
|
// Unparseable and missing fall back to the default.
|
|
is.Eq(5*time.Minute, c.Duration("bad", 5*time.Minute))
|
|
is.Eq(7*time.Second, c.Duration("missing", 7*time.Second))
|
|
is.Eq(time.Duration(0), c.Duration("missing"))
|
|
}
|
|
|
|
func TestConfig_GetValue_negativeIndex(t *testing.T) {
|
|
is := assert.New(t)
|
|
|
|
c := New("test-neg")
|
|
err := c.LoadData(map[string]any{
|
|
"arr": []any{"a", "b", "c"},
|
|
})
|
|
is.NoErr(err)
|
|
|
|
// A negative slice index must not panic; it is simply not found.
|
|
is.NotPanics(func() {
|
|
v, ok := c.GetValue("arr.-1")
|
|
is.False(ok)
|
|
is.Nil(v)
|
|
})
|
|
|
|
is.NotPanics(func() {
|
|
is.False(c.Exists("arr.-1"))
|
|
})
|
|
}
|