313 lines
10 KiB
Go
313 lines
10 KiB
Go
package engine
|
|
|
|
import (
|
|
"errors"
|
|
"math"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/ConfigKit/internal/document"
|
|
)
|
|
|
|
type namedSmall int8
|
|
|
|
type validatedText string
|
|
|
|
func (value validatedText) MarshalText() ([]byte, error) {
|
|
return []byte(value), nil
|
|
}
|
|
|
|
func (value *validatedText) UnmarshalText(text []byte) error {
|
|
if string(text) == "bad-secret-canary" {
|
|
return errors.New("CANARY_TEXT_ERROR: bad-secret-canary")
|
|
}
|
|
*value = validatedText(text)
|
|
return nil
|
|
}
|
|
|
|
func TestDecodeAppliesInputOverDetachedDefaults(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type nested struct {
|
|
A string `yaml:"a"`
|
|
B string `yaml:"b"`
|
|
}
|
|
type config struct {
|
|
Enabled bool `yaml:"enabled"`
|
|
Workers int `yaml:"workers"`
|
|
Label string `yaml:"label"`
|
|
Nested nested `yaml:"nested"`
|
|
EmptyMapping nested `yaml:"empty_mapping"`
|
|
Objects map[string]nested `yaml:"objects"`
|
|
Sequence []string `yaml:"sequence"`
|
|
Replacement []string `yaml:"replacement"`
|
|
Pointer *nested `yaml:"pointer"`
|
|
NilPointer *nested `yaml:"nil_pointer"`
|
|
Nullable map[string]string `yaml:"nullable"`
|
|
Dynamic any `yaml:"dynamic"`
|
|
DynamicShape any `yaml:"dynamic_shape"`
|
|
DynamicNull any `yaml:"dynamic_null"`
|
|
Fixed [2]int `yaml:"fixed"`
|
|
Small namedSmall `yaml:"small"`
|
|
Delay time.Duration `yaml:"delay"`
|
|
Custom validatedText `yaml:"custom"`
|
|
}
|
|
defaults := config{
|
|
Enabled: true,
|
|
Workers: 4,
|
|
Label: "default",
|
|
Nested: nested{A: "keep", B: "before"},
|
|
EmptyMapping: nested{A: "keep-empty", B: "keep-empty"},
|
|
Objects: map[string]nested{
|
|
"existing": {A: "keep-map", B: "before"},
|
|
},
|
|
Sequence: []string{"default"},
|
|
Replacement: []string{"default"},
|
|
Pointer: &nested{A: "keep-pointer", B: "before"},
|
|
Nullable: map[string]string{"default": "value"},
|
|
Dynamic: map[string]any{"keep": "default", "count": int64(4)},
|
|
DynamicShape: nested{A: "keep-dynamic", B: "before"},
|
|
DynamicNull: "default",
|
|
Fixed: [2]int{1, 2},
|
|
Small: 7,
|
|
Delay: time.Second,
|
|
Custom: "default",
|
|
}
|
|
input := `
|
|
enabled: false
|
|
workers: 0
|
|
label: ""
|
|
nested: {b: changed}
|
|
empty_mapping: {}
|
|
objects:
|
|
existing: {b: changed}
|
|
new: {b: added}
|
|
sequence: []
|
|
replacement: [one, two]
|
|
pointer: {b: changed}
|
|
nil_pointer: {b: added}
|
|
nullable: null
|
|
dynamic: {count: 0, fraction: 1.5}
|
|
dynamic_shape: {b: changed}
|
|
dynamic_null: null
|
|
fixed: [3, 4]
|
|
small: -8
|
|
delay: 1.5s
|
|
custom: accepted
|
|
`
|
|
schema := mustSchemaFor[config](t)
|
|
documentRoot := parseDocumentForDecode(t, input)
|
|
decoded, issues := decodeConfiguration(schema, reflect.ValueOf(defaults), documentRoot)
|
|
if len(issues) != 0 {
|
|
t.Fatalf("decode issues = %#v", issues)
|
|
}
|
|
got := decoded.value.Interface().(config)
|
|
if got.Enabled || got.Workers != 0 || got.Label != "" {
|
|
t.Fatalf("explicit zero values lost: %#v", got)
|
|
}
|
|
if got.Nested != (nested{A: "keep", B: "changed"}) || got.EmptyMapping != defaults.EmptyMapping {
|
|
t.Fatalf("mapping defaults = %#v / %#v", got.Nested, got.EmptyMapping)
|
|
}
|
|
if got.Objects["existing"] != (nested{A: "keep-map", B: "changed"}) || got.Objects["new"] != (nested{B: "added"}) {
|
|
t.Fatalf("map defaults = %#v", got.Objects)
|
|
}
|
|
if got.Sequence == nil || len(got.Sequence) != 0 || !reflect.DeepEqual(got.Replacement, []string{"one", "two"}) {
|
|
t.Fatalf("sequence replacement = %#v / %#v", got.Sequence, got.Replacement)
|
|
}
|
|
if got.Pointer == defaults.Pointer || *got.Pointer != (nested{A: "keep-pointer", B: "changed"}) || got.NilPointer == nil || *got.NilPointer != (nested{B: "added"}) {
|
|
t.Fatalf("pointer defaults = %#v / %#v", got.Pointer, got.NilPointer)
|
|
}
|
|
if got.Nullable != nil || got.DynamicNull != nil {
|
|
t.Fatalf("null values = %#v / %#v", got.Nullable, got.DynamicNull)
|
|
}
|
|
dynamic := got.Dynamic.(map[string]any)
|
|
if dynamic["keep"] != "default" || dynamic["count"] != int64(0) || dynamic["fraction"] != float64(1.5) {
|
|
t.Fatalf("dynamic mapping = %#v", dynamic)
|
|
}
|
|
if got.DynamicShape != (nested{A: "keep-dynamic", B: "changed"}) {
|
|
t.Fatalf("dynamic concrete mapping = %#v", got.DynamicShape)
|
|
}
|
|
if got.Fixed != [2]int{3, 4} || got.Small != -8 || got.Delay != 1500*time.Millisecond || got.Custom != "accepted" {
|
|
t.Fatalf("scalar decoding = %#v", got)
|
|
}
|
|
|
|
for _, path := range []Path{Keys(), Keys("enabled"), Keys("nested"), Keys("nested", "b"), Keys("empty_mapping")} {
|
|
if _, ok := decoded.presence[path.String()]; !ok {
|
|
t.Errorf("explicit path %q missing", path.String())
|
|
}
|
|
}
|
|
if _, ok := decoded.presence[Keys("nested", "a").String()]; ok {
|
|
t.Fatal("parent mapping made omitted child explicit")
|
|
}
|
|
if decoded.origins[Keys("nested", "a").String()].Layer != LayerDefault || decoded.origins[Keys("nested", "b").String()].Layer != LayerBase {
|
|
t.Fatalf("origins = %#v", decoded.origins)
|
|
}
|
|
if decoded.origins[Keys("nested", "b").String()].Locations[0].Line == 0 {
|
|
t.Fatal("input origin lost source coordinates")
|
|
}
|
|
|
|
defaults.Objects["existing"] = nested{A: "mutated"}
|
|
defaults.Pointer.B = "mutated"
|
|
defaults.Sequence[0] = "mutated"
|
|
if got.Objects["existing"].A != "keep-map" || got.Pointer.B != "changed" || len(got.Sequence) != 0 {
|
|
t.Fatal("decoded value aliases defaults")
|
|
}
|
|
got.Pointer.B = "caller mutation"
|
|
if mappingValue(t, mappingValue(t, decoded.final, "pointer"), "b").Text != "changed" {
|
|
t.Fatal("final snapshot aliases returned typed value")
|
|
}
|
|
if mappingValue(t, mappingValue(t, decoded.baseline, "nested"), "b").Text != "before" {
|
|
t.Fatal("baseline snapshot was mutated by decode")
|
|
}
|
|
}
|
|
|
|
func TestDecodeDefaultsOnlyAndRepeatedResultsAreIndependent(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Values map[string][]string `yaml:"values"`
|
|
}
|
|
defaults := config{Values: map[string][]string{"one": {"a"}}}
|
|
schema := mustSchemaFor[config](t)
|
|
first, issues := decodeConfiguration(schema, reflect.ValueOf(defaults), nil)
|
|
if len(issues) != 0 {
|
|
t.Fatal(issues)
|
|
}
|
|
second, issues := decodeConfiguration(schema, reflect.ValueOf(defaults), nil)
|
|
if len(issues) != 0 {
|
|
t.Fatal(issues)
|
|
}
|
|
firstValue := first.value.Interface().(config)
|
|
secondValue := second.value.Interface().(config)
|
|
firstValue.Values["one"][0] = "changed"
|
|
if secondValue.Values["one"][0] != "a" || defaults.Values["one"][0] != "a" {
|
|
t.Fatal("repeated defaults-only results share aliases")
|
|
}
|
|
if len(first.presence) != 0 || first.origins[Keys("values", "one").String()].Layer != LayerDefault {
|
|
t.Fatalf("defaults-only metadata = %#v / %#v", first.presence, first.origins)
|
|
}
|
|
}
|
|
|
|
func TestDecodeCollectsIndependentTypeAndShapeFailures(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type nested struct {
|
|
Known int `yaml:"known"`
|
|
}
|
|
type config struct {
|
|
Small int8 `yaml:"small"`
|
|
Unsigned uint8 `yaml:"unsigned"`
|
|
Number float32 `yaml:"number"`
|
|
Text string `yaml:"text"`
|
|
Flag bool `yaml:"flag"`
|
|
Delay time.Duration `yaml:"delay"`
|
|
Fixed [2]int `yaml:"fixed"`
|
|
Nested nested `yaml:"nested"`
|
|
Custom validatedText `yaml:"custom"`
|
|
Dynamic any `yaml:"dynamic"`
|
|
}
|
|
input := `
|
|
small: 128
|
|
unsigned: -1
|
|
number: 1e999
|
|
text: 3
|
|
flag: "true"
|
|
delay: 10
|
|
fixed: [1]
|
|
nested: {first_unknown: 1, second_unknown: 2}
|
|
custom: bad-secret-canary
|
|
dynamic: 9223372036854775808
|
|
`
|
|
schema := mustSchemaFor[config](t)
|
|
_, issues := decodeConfiguration(schema, reflect.ValueOf(config{Custom: "ok"}), parseDocumentForDecode(t, input))
|
|
if len(issues) != 11 {
|
|
t.Fatalf("issues = %d: %#v", len(issues), issues)
|
|
}
|
|
want := map[string]Code{
|
|
"/small": CodeDecodeRange,
|
|
"/unsigned": CodeDecodeType,
|
|
"/number": CodeDecodeRange,
|
|
"/text": CodeDecodeType,
|
|
"/flag": CodeDecodeType,
|
|
"/delay": CodeDecodeType,
|
|
"/fixed": CodeDecodeArrayLength,
|
|
"/nested/first_unknown": CodeDecodeUnknownField,
|
|
"/nested/second_unknown": CodeDecodeUnknownField,
|
|
"/custom": CodeDecodeText,
|
|
"/dynamic": CodeDecodeRange,
|
|
}
|
|
for _, issue := range issues {
|
|
if wantCode, ok := want[issue.path.String()]; !ok || wantCode != issue.code {
|
|
t.Errorf("unexpected issue %#v", issue)
|
|
}
|
|
if issue.location.Line == 0 {
|
|
t.Errorf("issue lost input location: %#v", issue)
|
|
}
|
|
if strings.Contains(issue.message, "CANARY") || strings.Contains(issue.message, "bad-secret") {
|
|
t.Errorf("issue exposed value: %#v", issue)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDecodeNullabilityAndNestedMapStrictness(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type nested struct {
|
|
Value int `yaml:"value"`
|
|
}
|
|
type config struct {
|
|
Scalar int `yaml:"scalar"`
|
|
Object nested `yaml:"object"`
|
|
Array [1]int `yaml:"array"`
|
|
Map map[string]nested `yaml:"map"`
|
|
}
|
|
input := "scalar: null\nobject: null\narray: null\nmap:\n item: {unknown: 1}\n"
|
|
_, issues := decodeConfiguration(mustSchemaFor[config](t), reflect.ValueOf(config{}), parseDocumentForDecode(t, input))
|
|
want := map[string]Code{
|
|
"/scalar": CodeDecodeNull,
|
|
"/object": CodeDecodeNull,
|
|
"/array": CodeDecodeNull,
|
|
"/map/item/unknown": CodeDecodeUnknownField,
|
|
}
|
|
if len(issues) != len(want) {
|
|
t.Fatalf("issues = %#v", issues)
|
|
}
|
|
for _, issue := range issues {
|
|
if want[issue.path.String()] != issue.code {
|
|
t.Errorf("issue = %#v", issue)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDecodeRejectsInvalidDefaultsBeforeApplyingInput(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Name string `yaml:"name"`
|
|
Extras map[string]any `yaml:",inline"`
|
|
Float float64 `yaml:"float"`
|
|
}
|
|
schema := mustSchemaFor[config](t)
|
|
for name, defaults := range map[string]config{
|
|
"inline collision": {Name: "declared", Extras: map[string]any{"name": "duplicate"}},
|
|
"non-finite": {Float: math.NaN()},
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
if _, issues := decodeConfiguration(schema, reflect.ValueOf(defaults), parseDocumentForDecode(t, "{}\n")); len(issues) != 1 || !strings.HasPrefix(string(issues[0].code), "schema.") {
|
|
t.Fatalf("issues = %#v", issues)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func parseDocumentForDecode(t *testing.T, input string) *document.Node {
|
|
t.Helper()
|
|
parsed, diagnostics := parseSource(Bytes("decode.yml", []byte(input)), "source-1", defaultParseLimits())
|
|
if len(diagnostics) != 0 {
|
|
t.Fatalf("parse diagnostics = %#v", diagnostics)
|
|
}
|
|
return parsed.document
|
|
}
|