408 lines
11 KiB
Go
408 lines
11 KiB
Go
package config
|
|
|
|
import (
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"git.avsdev.uk/Go/job-search/internal/util"
|
|
)
|
|
|
|
// errRejected is the error testValidated.validate rejects "bad" with.
|
|
var errRejected = errors.New("rejected")
|
|
|
|
// Test sections exercising every field shape section.go supports.
|
|
type testInner struct {
|
|
Name string `cfg:"name" default:"inner"`
|
|
}
|
|
|
|
// testItem is the item type of a list of sections.
|
|
type testItem struct {
|
|
Name string `cfg:"name" default:"item"`
|
|
N int `cfg:"n"`
|
|
Wait time.Duration `cfg:"wait"`
|
|
}
|
|
|
|
type testEmbedded struct {
|
|
On bool `cfg:"on" default:"true"`
|
|
}
|
|
|
|
type testSection struct {
|
|
testEmbedded
|
|
Str string `cfg:"str" default:"hello"`
|
|
Int int `cfg:"int" default:"-42"`
|
|
Int8 int8 `cfg:"int8"`
|
|
Uint uint `cfg:"uint" default:"7"`
|
|
Uint16 uint16 `cfg:"uint16"`
|
|
Float float64 `cfg:"float" default:"1.5"`
|
|
Float32 float32 `cfg:"float32"`
|
|
Dur time.Duration `cfg:"dur" default:"90s"`
|
|
Size util.ByteSize `cfg:"size" default:"32KiB"`
|
|
When time.Time `cfg:"when"`
|
|
Slice []string `cfg:"slice"`
|
|
Items []testItem `cfg:"items"`
|
|
Inner testInner `cfg:"inner"`
|
|
NoTag string
|
|
Skipped string `cfg:"-"`
|
|
Empty string `cfg:""`
|
|
unexport string `cfg:"unexported"` //nolint:unused // checks unexported fields are ignored
|
|
}
|
|
|
|
type testValidated struct {
|
|
Value string `cfg:"value"`
|
|
}
|
|
|
|
func (c *testValidated) validate(key string, value any) error {
|
|
if key == "value" && value.(string) == "bad" {
|
|
return errRejected
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestKeysOf(t *testing.T) {
|
|
got := keysOf(&testSection{})
|
|
want := []string{"on", "str", "int", "int8", "uint", "uint16", "float",
|
|
"float32", "dur", "size", "when", "slice", "items", "inner"}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Errorf("keysOf = %v; want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestFieldsOfSkipsUntagged(t *testing.T) {
|
|
for _, f := range fieldsOf(reflect.TypeOf(testSection{})) {
|
|
switch f.key {
|
|
case "", "-", "unexported":
|
|
t.Errorf("fieldsOf included field with key %q", f.key)
|
|
}
|
|
if f.key == "when" && f.section {
|
|
t.Error("time.Time field treated as a section")
|
|
}
|
|
if f.key == "inner" && !f.section {
|
|
t.Error("struct field not treated as a section")
|
|
}
|
|
if f.key == "items" && f.section {
|
|
t.Error("list of sections treated as a section")
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMapOf(t *testing.T) {
|
|
var s testSection
|
|
if err := applyDefaults(&s); err != nil {
|
|
t.Fatalf("applyDefaults: %v", err)
|
|
}
|
|
m := mapOf(s)
|
|
if got := m["str"]; got != "hello" {
|
|
t.Errorf("m[str] = %#v", got)
|
|
}
|
|
if got := m["on"]; got != true {
|
|
t.Errorf("m[on] (promoted) = %#v", got)
|
|
}
|
|
if got := m["dur"]; got != "1m30s" {
|
|
t.Errorf("m[dur] = %#v; want the duration as a string", got)
|
|
}
|
|
inner, ok := m["inner"].(map[string]any)
|
|
if !ok {
|
|
t.Fatalf("m[inner] = %#v; want nested map", m["inner"])
|
|
}
|
|
if inner["name"] != "inner" {
|
|
t.Errorf("m[inner][name] = %#v", inner["name"])
|
|
}
|
|
if _, ok := m["inner.name"]; ok {
|
|
t.Error("mapOf produced a flattened key")
|
|
}
|
|
// Pointer and value give the same result.
|
|
if !reflect.DeepEqual(m, mapOf(&s)) {
|
|
t.Error("mapOf(&s) != mapOf(s)")
|
|
}
|
|
}
|
|
|
|
func TestFlattenOfPrefix(t *testing.T) {
|
|
m := flattenOf("p", testSection{
|
|
Dur: 90 * time.Second,
|
|
})
|
|
for _, k := range []string{"p.str", "p.on", "p.inner.name"} {
|
|
if _, ok := m[k]; !ok {
|
|
t.Errorf("flattenOf missing %q in %v", k, m)
|
|
}
|
|
}
|
|
if got := m["p.dur"]; got != "1m30s" {
|
|
t.Errorf("m[p.dur] = %#v; want the duration as a string", got)
|
|
}
|
|
}
|
|
|
|
func TestStructValuePanics(t *testing.T) {
|
|
defer func() {
|
|
if recover() == nil {
|
|
t.Error("structValue(int) did not panic")
|
|
}
|
|
}()
|
|
structValue(42)
|
|
}
|
|
|
|
func TestApplyDefaults(t *testing.T) {
|
|
var s testSection
|
|
if err := applyDefaults(&s); err != nil {
|
|
t.Fatalf("applyDefaults: %v", err)
|
|
}
|
|
want := testSection{
|
|
testEmbedded: testEmbedded{
|
|
On: true,
|
|
},
|
|
Str: "hello",
|
|
Int: -42,
|
|
Uint: 7,
|
|
Float: 1.5,
|
|
Dur: 90 * time.Second,
|
|
Size: 32 << 10,
|
|
Inner: testInner{
|
|
Name: "inner",
|
|
},
|
|
}
|
|
if !reflect.DeepEqual(s, want) {
|
|
t.Errorf("applyDefaults = %+v; want %+v", s, want)
|
|
}
|
|
}
|
|
|
|
func TestApplyDefaultsInvalid(t *testing.T) {
|
|
var bad struct {
|
|
N int `cfg:"n" default:"nope"`
|
|
}
|
|
err := applyDefaults(&bad)
|
|
if err == nil || !strings.Contains(err.Error(), "invalid default for n") {
|
|
t.Errorf("applyDefaults = %v; want invalid default error", err)
|
|
}
|
|
|
|
var badNested struct {
|
|
Sub struct {
|
|
D time.Duration `cfg:"d" default:"forever"`
|
|
} `cfg:"sub"`
|
|
}
|
|
err = applyDefaults(&badNested)
|
|
if err == nil || !strings.Contains(err.Error(), "sub.d") {
|
|
t.Errorf("applyDefaults nested = %v; want error naming sub.d", err)
|
|
}
|
|
}
|
|
|
|
func TestTypeOf(t *testing.T) {
|
|
tests := []struct {
|
|
key string
|
|
want reflect.Kind
|
|
}{
|
|
{"str", reflect.String},
|
|
{"int", reflect.Int},
|
|
{"uint", reflect.Uint},
|
|
{"float", reflect.Float64},
|
|
{"on", reflect.Bool},
|
|
{"dur", reflect.String}, // durations are read as strings
|
|
{"size", reflect.String}, // byte sizes are read as strings
|
|
{"when", reflect.Struct},
|
|
{"slice", reflect.Slice},
|
|
{"items", reflect.Slice},
|
|
{"inner.name", reflect.String},
|
|
}
|
|
for _, tt := range tests {
|
|
got, err := typeOf(testSection{}, tt.key)
|
|
if err != nil || got != tt.want {
|
|
t.Errorf("typeOf(%q) = %v, %v; want %v", tt.key, got, err, tt.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestUnknownKeys(t *testing.T) {
|
|
keys := []string{
|
|
"missing",
|
|
"inner", // section without sub-key
|
|
"str.sub", // value with a sub-key
|
|
"inner.missing", // unknown nested key
|
|
"NoTag", // untagged field
|
|
"unexported",
|
|
"",
|
|
}
|
|
var s testSection
|
|
for _, key := range keys {
|
|
if k, err := typeOf(s, key); !errors.Is(err, errUnknownKey) ||
|
|
k != reflect.Invalid {
|
|
t.Errorf("typeOf(%q) = %v, %v; want Invalid, errUnknownKey", key, k, err)
|
|
}
|
|
if v, err := valueOf(s, key); !errors.Is(err, errUnknownKey) || v != nil {
|
|
t.Errorf("valueOf(%q) = %v, %v; want nil, errUnknownKey", key, v, err)
|
|
}
|
|
if err := setValue(&s, key, "x"); !errors.Is(err, errUnknownKey) {
|
|
t.Errorf("setValue(%q) = %v; want errUnknownKey", key, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSetValue(t *testing.T) {
|
|
tests := []struct {
|
|
key string
|
|
value any
|
|
want any
|
|
}{
|
|
// strings are parsed
|
|
{"str", "world", "world"},
|
|
{"on", "false", false},
|
|
{"int", "123", 123},
|
|
{"int8", "-128", int8(-128)},
|
|
{"uint", "9", uint(9)},
|
|
{"uint16", "65535", uint16(65535)},
|
|
{"float", "2.25", 2.25},
|
|
{"float32", "0.5", float32(0.5)},
|
|
{"dur", "1h30m", "1h30m0s"}, // durations are given out as strings
|
|
{"size", "1 mb", "1MB"}, // byte sizes are given out as strings
|
|
{"size", "1.5KiB", "1536B"},
|
|
{"size", "4096", "4KiB"},
|
|
{"size", "-1", "-1"}, // no limit
|
|
{"slice", " a, b ,, c ", []string{"a", "b", "c"}},
|
|
{"slice", "", []string(nil)},
|
|
{"inner.name", "nested", "nested"},
|
|
// values of the field's type are used as-is
|
|
{"int", 5, 5},
|
|
{"on", true, true},
|
|
{"dur", 3 * time.Second, "3s"},
|
|
{"size", util.ByteSize(2048), "2KiB"},
|
|
{"slice", []string{"a", "b"}, []string{"a", "b"}},
|
|
{"slice", []string{}, []string(nil)}, // empty lists are stored as nil
|
|
// lists of sections are given out as lists of maps; items start
|
|
// from their defaults and their values are parsed
|
|
{
|
|
"items",
|
|
`[{"n": "1", "wait": "2s"}, {"name": "b", "n": 2}]`,
|
|
[]map[string]any{
|
|
{"name": "item", "n": 1, "wait": "2s"},
|
|
{"name": "b", "n": 2, "wait": "0s"},
|
|
},
|
|
},
|
|
{"items", []any{map[string]any{"name": "a", "n": 3}}, []map[string]any{
|
|
{"name": "a", "n": 3, "wait": "0s"},
|
|
}},
|
|
{"items", []map[string]any{{"name": "a"}}, []map[string]any{
|
|
{"name": "a", "n": 0, "wait": "0s"},
|
|
}},
|
|
{"items", []testItem{{
|
|
Name: "a",
|
|
N: 4,
|
|
}}, []map[string]any{
|
|
{"name": "a", "n": 4, "wait": "0s"},
|
|
}},
|
|
{"items", "", []map[string]any(nil)},
|
|
{"items", "[]", []map[string]any(nil)},
|
|
{"items", []testItem{}, []map[string]any(nil)},
|
|
{"items", nil, []map[string]any(nil)},
|
|
{"when", time.Unix(0, 0).UTC(), time.Unix(0, 0).UTC()},
|
|
}
|
|
for _, tt := range tests {
|
|
var s testSection
|
|
if err := setValue(&s, tt.key, tt.value); err != nil {
|
|
t.Errorf("setValue(%q, %#v): %v", tt.key, tt.value, err)
|
|
continue
|
|
}
|
|
got, err := valueOf(s, tt.key)
|
|
if err != nil || !reflect.DeepEqual(got, tt.want) {
|
|
t.Errorf(
|
|
"after setValue(%q, %#v): valueOf = %#v, %v; want %#v",
|
|
tt.key,
|
|
tt.value,
|
|
got,
|
|
err,
|
|
tt.want,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestSetValueErrors(t *testing.T) {
|
|
tests := []struct {
|
|
key string
|
|
value any
|
|
want string
|
|
}{
|
|
{"int", "abc", "unable to convert"},
|
|
{"int8", "200", "unable to convert"}, // out of range
|
|
{"uint", "-1", "unable to convert"},
|
|
{"float", "x", "unable to convert"},
|
|
{"on", "maybe", "unable to convert"},
|
|
{"dur", "soon", "unable to convert to duration"},
|
|
{"items", "not json", "unable to convert to a list of config.testItem"},
|
|
{"items", `[{"bogus": 1}]`, `item 0: config: unknown configuration key "bogus"`},
|
|
{"items", `[{"n": "x"}]`, "item 0: n: unable to convert"},
|
|
{"items", []any{"a"}, "item 0: config: unsupported type string"},
|
|
{"items", 5, "unsupported type int"},
|
|
{"size", "lots", "unable to convert to byte size"},
|
|
{"size", "-1KB", "unable to convert to byte size"},
|
|
{"size", "16EiB", "too large"},
|
|
{"when", "2024-01-01", "unsupported type string"},
|
|
{"int", 1.5, "unsupported type float64"},
|
|
{"int", int64(1), "unsupported type int64"},
|
|
{"str", nil, "unsupported type <nil>"},
|
|
}
|
|
for _, tt := range tests {
|
|
var s testSection
|
|
before := s
|
|
err := setValue(&s, tt.key, tt.value)
|
|
if err == nil || !strings.Contains(err.Error(), tt.want) {
|
|
t.Errorf(
|
|
"setValue(%q, %#v) = %v; want error containing %q",
|
|
tt.key,
|
|
tt.value,
|
|
err,
|
|
tt.want,
|
|
)
|
|
}
|
|
if !reflect.DeepEqual(s, before) {
|
|
t.Errorf(
|
|
"setValue(%q, %#v) modified the section on error", tt.key, tt.value,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
// A []string is given out as a copy, so changing it leaves the section as it
|
|
// was.
|
|
func TestValueOfSliceIsACopy(t *testing.T) {
|
|
s := testSection{
|
|
Slice: []string{"a", "b"},
|
|
}
|
|
got, err := valueOf(s, "slice")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got.([]string)[0] = "changed"
|
|
if s.Slice[0] != "a" {
|
|
t.Errorf("changing valueOf's slice changed the section: %v", s.Slice)
|
|
}
|
|
}
|
|
|
|
func TestSetValueValidator(t *testing.T) {
|
|
var s testValidated
|
|
if err := setValue(&s, "value", "good"); err != nil || s.Value != "good" {
|
|
t.Errorf("setValue(good) = %v, Value = %q", err, s.Value)
|
|
}
|
|
if err := setValue(&s, "value", "bad"); !errors.Is(err, errRejected) {
|
|
t.Errorf("setValue(bad) = %v; want errRejected", err)
|
|
}
|
|
if s.Value != "good" {
|
|
t.Errorf("rejected value was stored: %q", s.Value)
|
|
}
|
|
|
|
// The validator of the section holding the field is used for nested keys.
|
|
var outer struct {
|
|
V testValidated `cfg:"v"`
|
|
}
|
|
if err := setValue(&outer, "v.value", "bad"); !errors.Is(err, errRejected) {
|
|
t.Errorf("nested setValue(bad) = %v; want errRejected", err)
|
|
}
|
|
}
|
|
|
|
// parseString handles string fields too, although convert assigns a string
|
|
// to a string field before reaching it.
|
|
func TestParseStringString(t *testing.T) {
|
|
v, err := parseString("text", reflect.TypeOf(""))
|
|
if err != nil || v.Interface() != "text" {
|
|
t.Errorf("parseString(text, string) = %v, %v", v, err)
|
|
}
|
|
}
|