605 lines
23 KiB
Go
605 lines
23 KiB
Go
package configkit
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestLoadSingleSourceKindsAndDefaultsOnly(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Name string `yaml:"name"`
|
|
}
|
|
input := []byte("name: configured\n")
|
|
temporary := t.TempDir()
|
|
filename := filepath.Join(temporary, "config.yml")
|
|
if err := os.WriteFile(filename, input, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
source func() Source
|
|
want string
|
|
wantSources int
|
|
}{
|
|
{name: "file", source: func() Source { return File(filename) }, want: "configured", wantSources: 1},
|
|
{name: "bytes", source: func() Source { return Bytes("memory.yml", input) }, want: "configured", wantSources: 1},
|
|
{name: "reader", source: func() Source { return Reader("reader.yml", strings.NewReader(string(input))) }, want: "configured", wantSources: 1},
|
|
{name: "no source", source: NoSource, want: "default", wantSources: 0},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
var defaultsCalls atomic.Int32
|
|
result, err := Load(test.source(), Options[config]{Definition: Definition[config]{
|
|
Defaults: func() config {
|
|
defaultsCalls.Add(1)
|
|
return config{Name: "default"}
|
|
},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Name != test.want || defaultsCalls.Load() != 1 || len(result.Sources()) != test.wantSources {
|
|
t.Fatalf("result = %#v, calls = %d, sources = %#v", result.Config, defaultsCalls.Load(), result.Sources())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoadVersionStatesWarningsAndSafeFailures(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
SchemaVersion *string `yaml:"schema_version"`
|
|
}
|
|
versionPath := Keys("schema_version")
|
|
tests := []struct {
|
|
name string
|
|
source Source
|
|
want Version
|
|
wantLine int
|
|
wantErr Code
|
|
returnOnly bool
|
|
}{
|
|
{name: "absent", source: Bytes("absent.yml", []byte("{}\n")), want: Version{}, wantLine: 1},
|
|
{name: "no source absent", source: NoSource(), want: Version{}},
|
|
{name: "null", source: Bytes("null.yml", []byte("schema_version: null\n")), want: Version{Present: true, Null: true}, wantLine: 1},
|
|
{name: "string", source: Bytes("string.yml", []byte("schema_version: app.v1\n")), want: Version{Present: true, Text: "app.v1"}, wantLine: 1},
|
|
{name: "integer", source: Bytes("integer.yml", []byte("schema_version: 1\n")), want: Version{Present: true, Text: "1"}, wantLine: 1},
|
|
{name: "boolean", source: Bytes("boolean.yml", []byte("schema_version: true\n")), wantErr: CodeVersionType},
|
|
{name: "sequence", source: Bytes("sequence.yml", []byte("schema_version: []\n")), wantErr: CodeVersionType},
|
|
{name: "returned error", source: Bytes("return.yml", []byte("{}\n")), wantErr: CodeVersionHookFailed, returnOnly: true},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
called := false
|
|
rule := &VersionRule{Path: versionPath, Check: func(version Version, validation *Validation) error {
|
|
called = true
|
|
if test.returnOnly {
|
|
return errors.New("CANARY_VERSION_ERROR")
|
|
}
|
|
if version != test.want {
|
|
t.Errorf("version = %#v, want %#v", version, test.want)
|
|
}
|
|
validation.Warning(versionPath, "review schema compatibility", Keys("missing_related"))
|
|
return nil
|
|
}}
|
|
result, err := Load(test.source, Options[config]{Definition: Definition[config]{Version: rule}})
|
|
if test.wantErr != "" {
|
|
if result != nil || err == nil {
|
|
t.Fatalf("result, err = %#v, %v", result, err)
|
|
}
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) {
|
|
t.Fatalf("error type = %T", err)
|
|
}
|
|
diagnostics := loadError.Diagnostics()
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != test.wantErr || strings.Contains(diagnostics[0].Message, "CANARY") {
|
|
t.Fatalf("diagnostics = %#v", diagnostics)
|
|
}
|
|
if test.wantErr == CodeVersionType && called {
|
|
t.Fatal("checker ran for an unsupported version kind")
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
diagnostics := result.Diagnostics()
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != CodeVersionWarning || diagnostics[0].Severity != SeverityWarning {
|
|
t.Fatalf("diagnostics = %#v", diagnostics)
|
|
}
|
|
if test.wantLine == 0 && (diagnostics[0].Primary != nil || len(diagnostics[0].Related) != 0) {
|
|
t.Fatalf("synthetic diagnostic locations = %#v", diagnostics[0])
|
|
}
|
|
if test.wantLine != 0 && (diagnostics[0].Primary == nil || diagnostics[0].Primary.Line != test.wantLine || len(diagnostics[0].Related) != 1) {
|
|
t.Fatalf("diagnostic locations = %#v", diagnostics[0])
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoadDecodesIntegerVersionOnlyAtConfiguredStringPath(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type stringConfig struct {
|
|
Version string `yaml:"version"`
|
|
}
|
|
type pointerConfig struct {
|
|
Version *string `yaml:"version"`
|
|
}
|
|
versionPath := Keys("version")
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
source string
|
|
load func(Source, *VersionRule) (string, error)
|
|
}{
|
|
{name: "integer into string", source: "version: 4\n", load: func(source Source, rule *VersionRule) (string, error) {
|
|
result, err := Load(source, Options[stringConfig]{Definition: Definition[stringConfig]{Version: rule}})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return result.Config.Version, nil
|
|
}},
|
|
{name: "string into string", source: "version: \"4\"\n", load: func(source Source, rule *VersionRule) (string, error) {
|
|
result, err := Load(source, Options[stringConfig]{Definition: Definition[stringConfig]{Version: rule}})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return result.Config.Version, nil
|
|
}},
|
|
{name: "integer into pointer", source: "version: 4\n", load: func(source Source, rule *VersionRule) (string, error) {
|
|
result, err := Load(source, Options[pointerConfig]{Definition: Definition[pointerConfig]{Version: rule}})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if result.Config.Version == nil {
|
|
t.Fatal("version pointer is nil")
|
|
}
|
|
return *result.Config.Version, nil
|
|
}},
|
|
{name: "string into pointer", source: "version: \"4\"\n", load: func(source Source, rule *VersionRule) (string, error) {
|
|
result, err := Load(source, Options[pointerConfig]{Definition: Definition[pointerConfig]{Version: rule}})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
if result.Config.Version == nil {
|
|
t.Fatal("version pointer is nil")
|
|
}
|
|
return *result.Config.Version, nil
|
|
}},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
var checked Version
|
|
rule := &VersionRule{Path: versionPath, Check: func(version Version, _ *Validation) error {
|
|
checked = version
|
|
return nil
|
|
}}
|
|
got, err := test.load(Bytes("version.yml", []byte(test.source)), rule)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got != "4" || checked != (Version{Present: true, Text: "4"}) {
|
|
t.Fatalf("value = %q, checked = %#v", got, checked)
|
|
}
|
|
})
|
|
}
|
|
|
|
if result, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[stringConfig]{}); result != nil {
|
|
t.Fatalf("load without rule = %#v, %v", result, err)
|
|
} else {
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) || len(loadError.Diagnostics()) != 1 || loadError.Diagnostics()[0].Code != CodeDecodeType {
|
|
t.Fatalf("load without rule error = %v", err)
|
|
}
|
|
}
|
|
type unrelatedConfig struct {
|
|
Version string `yaml:"version"`
|
|
Label string `yaml:"label"`
|
|
}
|
|
rule := &VersionRule{Path: versionPath, Check: func(Version, *Validation) error { return nil }}
|
|
if result, err := Load(Bytes("version.yml", []byte("version: 4\nlabel: 5\n")), Options[unrelatedConfig]{Definition: Definition[unrelatedConfig]{Version: rule}}); result != nil {
|
|
t.Fatalf("unrelated coercion = %#v, %v", result, err)
|
|
} else {
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) || len(loadError.Diagnostics()) != 1 || loadError.Diagnostics()[0].Code != CodeDecodeType || loadError.Diagnostics()[0].Path.String() != "/label" {
|
|
t.Fatalf("unrelated coercion error = %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLoadVersionScalarAndPathBoundaries(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Version string `yaml:"version"`
|
|
}
|
|
for _, test := range []struct {
|
|
name string
|
|
value string
|
|
want string
|
|
}{
|
|
{name: "zero", value: "0", want: "0"},
|
|
{name: "negative", value: "-7", want: "-7"},
|
|
{name: "negative zero", value: "-0", want: "-0"},
|
|
{name: "beyond int64", value: "123456789012345678901234567890", want: "123456789012345678901234567890"},
|
|
{name: "empty string", value: `""`, want: ""},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
var checked Version
|
|
rule := &VersionRule{Path: Keys("version"), Check: func(version Version, _ *Validation) error {
|
|
checked = version
|
|
return nil
|
|
}}
|
|
result, err := Load(Bytes("version.yml", []byte("version: "+test.value+"\n")), Options[config]{Definition: Definition[config]{Version: rule}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Version != test.want || checked.Text != test.want || !checked.Present || checked.Null {
|
|
t.Fatalf("configuration = %#v, checked = %#v", result.Config, checked)
|
|
}
|
|
})
|
|
}
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
value string
|
|
}{
|
|
{name: "fraction", value: "4.0"},
|
|
{name: "exponent", value: "4e0"},
|
|
{name: "boolean", value: "true"},
|
|
{name: "mapping", value: "{}"},
|
|
{name: "sequence", value: "[]"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
called := false
|
|
rule := &VersionRule{Path: Keys("version"), Check: func(Version, *Validation) error {
|
|
called = true
|
|
return nil
|
|
}}
|
|
result, err := Load(Bytes("version.yml", []byte("version: "+test.value+"\n")), Options[config]{Definition: Definition[config]{Version: rule}})
|
|
if result != nil || called {
|
|
t.Fatalf("result = %#v, checker called = %v", result, called)
|
|
}
|
|
requireDiagnostic(t, err, CodeVersionType, "/version")
|
|
})
|
|
}
|
|
|
|
type namedVersion string
|
|
type nested struct {
|
|
Versions map[string]**namedVersion `yaml:"versions"`
|
|
Sibling namedVersion `yaml:"sibling"`
|
|
}
|
|
parsed, err := ParsePath("/versions/0")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
rule := &VersionRule{Path: parsed, Check: func(version Version, _ *Validation) error {
|
|
if version.Text != "4" {
|
|
t.Errorf("version = %#v", version)
|
|
}
|
|
return nil
|
|
}}
|
|
result, err := Load(Bytes("nested.yml", []byte("versions:\n \"0\": 4\nsibling: quoted\n")), Options[nested]{Definition: Definition[nested]{Version: rule}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if result.Config.Versions["0"] == nil || *result.Config.Versions["0"] == nil || **result.Config.Versions["0"] != "4" || result.Config.Sibling != "quoted" {
|
|
t.Fatalf("nested configuration = %#v", result.Config)
|
|
}
|
|
type sequenceConfig struct {
|
|
Versions []namedVersion `yaml:"versions"`
|
|
}
|
|
sequenceResult, err := Load(Bytes("sequence.yml", []byte("versions: [6]\n")), Options[sequenceConfig]{Definition: Definition[sequenceConfig]{Version: &VersionRule{Path: parsed, Check: func(Version, *Validation) error { return nil }}}})
|
|
if err != nil || len(sequenceResult.Config.Versions) != 1 || sequenceResult.Config.Versions[0] != "6" {
|
|
t.Fatalf("sequence configuration = %#v, %v", sequenceResult, err)
|
|
}
|
|
|
|
type escaped struct {
|
|
Versions map[string]namedVersion `yaml:"versions"`
|
|
}
|
|
escapedPath, err := ParsePath("/versions/a~1b")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
escapedResult, err := Load(Bytes("escaped.yml", []byte("versions:\n a/b: 9\n")), Options[escaped]{Definition: Definition[escaped]{Version: &VersionRule{Path: escapedPath, Check: func(Version, *Validation) error { return nil }}}})
|
|
if err != nil || escapedResult.Config.Versions["a/b"] != "9" {
|
|
t.Fatalf("escaped configuration = %#v, %v", escapedResult, err)
|
|
}
|
|
|
|
siblingRule := &VersionRule{Path: Keys("versions", "target"), Check: func(Version, *Validation) error { return nil }}
|
|
if result, err := Load(Bytes("sibling.yml", []byte("versions:\n target: 4\n other: 5\n")), Options[escaped]{Definition: Definition[escaped]{Version: siblingRule}}); result != nil {
|
|
t.Fatalf("same-type sibling result = %#v, %v", result, err)
|
|
} else {
|
|
requireDiagnostic(t, err, CodeDecodeType, "/versions/other")
|
|
}
|
|
}
|
|
|
|
func TestLoadVersionDestinationTypesKeepOrdinaryDecoding(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
check := func(Version, *Validation) error { return nil }
|
|
t.Run("integer destination", func(t *testing.T) {
|
|
type config struct {
|
|
Version int8 `yaml:"version"`
|
|
}
|
|
result, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
if err != nil || result.Config.Version != 4 {
|
|
t.Fatalf("result = %#v, %v", result, err)
|
|
}
|
|
result, err = Load(Bytes("version.yml", []byte("version: 999\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
if result != nil {
|
|
t.Fatalf("range result = %#v", result)
|
|
}
|
|
requireDiagnostic(t, err, CodeDecodeRange, "/version")
|
|
result, err = Load(Bytes("version.yml", []byte("version: \"4\"\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
if result != nil {
|
|
t.Fatalf("quoted integer result = %#v", result)
|
|
}
|
|
requireDiagnostic(t, err, CodeDecodeType, "/version")
|
|
})
|
|
|
|
t.Run("dynamic destination", func(t *testing.T) {
|
|
type config struct {
|
|
Version any `yaml:"version"`
|
|
}
|
|
result, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
if err != nil || result.Config.Version != int64(4) {
|
|
t.Fatalf("result = %#v, %v", result, err)
|
|
}
|
|
result, err = Load(Bytes("version.yml", []byte("version: 123456789012345678901234567890\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
if result != nil {
|
|
t.Fatalf("range result = %#v", result)
|
|
}
|
|
requireDiagnostic(t, err, CodeDecodeRange, "/version")
|
|
})
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
load func() error
|
|
}{
|
|
{name: "text codec", load: func() error {
|
|
type config struct {
|
|
Version validatedText `yaml:"version"`
|
|
}
|
|
_, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
return err
|
|
}},
|
|
{name: "duration", load: func() error {
|
|
type config struct {
|
|
Version time.Duration `yaml:"version"`
|
|
}
|
|
_, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
return err
|
|
}},
|
|
{name: "secret", load: func() error {
|
|
type config struct {
|
|
Version Secret `yaml:"version"`
|
|
}
|
|
_, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: check}}})
|
|
return err
|
|
}},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
requireDiagnostic(t, test.load(), CodeDecodeType, "/version")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestLoadVersionPolicyStopsLaterHooks(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Version string `yaml:"version"`
|
|
}
|
|
var defaultsCalled, resolutionCalled, validationCalled bool
|
|
rule := &VersionRule{Path: Keys("version"), Check: func(version Version, validation *Validation) error {
|
|
if version.Text != "4" {
|
|
t.Errorf("version = %#v", version)
|
|
}
|
|
validation.Error(Keys("version"), "unsupported configuration version")
|
|
return nil
|
|
}}
|
|
result, err := Load(Bytes("version.yml", []byte("version: 4\n")), Options[config]{Definition: Definition[config]{
|
|
Defaults: func() config { defaultsCalled = true; return config{} },
|
|
Version: rule,
|
|
Resolve: func(*config, *Resolution) error { resolutionCalled = true; return nil },
|
|
Validate: func(*config, *Validation) { validationCalled = true },
|
|
}})
|
|
if result != nil || defaultsCalled || resolutionCalled || validationCalled {
|
|
t.Fatalf("result = %#v, hooks = %v/%v/%v", result, defaultsCalled, resolutionCalled, validationCalled)
|
|
}
|
|
requireDiagnostic(t, err, CodeVersionError, "/version")
|
|
}
|
|
|
|
func requireDiagnostic(t *testing.T, err error, code Code, path string) {
|
|
t.Helper()
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) {
|
|
t.Fatalf("error = %T %v", err, err)
|
|
}
|
|
diagnostics := loadError.Diagnostics()
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != code || diagnostics[0].Path.String() != path || diagnostics[0].Primary == nil {
|
|
t.Fatalf("diagnostics = %#v", diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestLoadVersionReportSuppressesReturnedErrorTextAndDefaults(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Name string `yaml:"name"`
|
|
}
|
|
var defaultsCalls atomic.Int32
|
|
result, err := Load(Bytes("version.yml", []byte("name: value\n")), Options[config]{Definition: Definition[config]{
|
|
Defaults: func() config {
|
|
defaultsCalls.Add(1)
|
|
return config{Name: "default"}
|
|
},
|
|
Version: &VersionRule{Path: Keys("schema_version"), Check: func(_ Version, validation *Validation) error {
|
|
validation.Error(Keys("schema_version"), "schema_version is required")
|
|
return errors.New("CANARY_RETURNED_ERROR")
|
|
}},
|
|
}})
|
|
if result != nil || err == nil || defaultsCalls.Load() != 0 {
|
|
t.Fatalf("result = %#v, err = %v, calls = %d", result, err, defaultsCalls.Load())
|
|
}
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) {
|
|
t.Fatalf("error type = %T", err)
|
|
}
|
|
diagnostics := loadError.Diagnostics()
|
|
if len(diagnostics) != 1 || diagnostics[0].Code != CodeVersionError || strings.Contains(diagnostics[0].Message, "CANARY") {
|
|
t.Fatalf("diagnostics = %#v", diagnostics)
|
|
}
|
|
}
|
|
|
|
func TestLoadMetadataReflectsDefaultsInputAndDetachedRecords(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type nested struct {
|
|
Kept string `yaml:"kept"`
|
|
Set string `yaml:"set"`
|
|
}
|
|
type config struct {
|
|
Nested nested `yaml:"nested"`
|
|
Nullable map[string]string `yaml:"nullable"`
|
|
}
|
|
result, err := Load(Bytes("metadata.yml", []byte("nested: {set: configured}\nnullable: null\n")), Options[config]{Definition: Definition[config]{
|
|
Defaults: func() config {
|
|
return config{Nested: nested{Kept: "default", Set: "default"}, Nullable: map[string]string{"key": "value"}}
|
|
},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
metadata := result.Metadata()
|
|
kept, ok := metadata.Lookup(Keys("nested", "kept"))
|
|
if !ok || kept.Explicit || kept.Origin.Layer != LayerDefault {
|
|
t.Fatalf("kept = %#v, %v", kept, ok)
|
|
}
|
|
set, ok := metadata.Lookup(Keys("nested", "set"))
|
|
if !ok || !set.Explicit || set.Origin.Layer != LayerBase || len(set.Origin.Locations) != 1 {
|
|
t.Fatalf("set = %#v, %v", set, ok)
|
|
}
|
|
nullable, ok := metadata.Lookup(Keys("nullable"))
|
|
if !ok || !nullable.Explicit || !nullable.Null || nullable.Origin.Layer != LayerBase {
|
|
t.Fatalf("nullable = %#v, %v", nullable, ok)
|
|
}
|
|
if metadata.IsExplicit(Keys("nested", "kept")) || !metadata.IsExplicit(Keys("nested", "set")) {
|
|
t.Fatal("explicit presence disagrees with lookup")
|
|
}
|
|
if history := metadata.History(Keys("nested", "set")); len(history) != 2 || history[0].Origin.Layer != LayerDefault || history[1].Origin.Layer != LayerBase || len(history[1].Previous) != 1 {
|
|
t.Fatalf("history = %#v", history)
|
|
}
|
|
|
|
set.Origin.Locations[0].Line = 99
|
|
history := metadata.History(Keys("nested", "set"))
|
|
history[1].Origin.Locations[0].Line = 99
|
|
sources := result.Sources()
|
|
sources[0].Label = "changed"
|
|
diagnostics := result.Diagnostics()
|
|
if diagnostics != nil {
|
|
diagnostics[0].Message = "changed"
|
|
}
|
|
fresh, _ := result.Metadata().Lookup(Keys("nested", "set"))
|
|
if fresh.Origin.Locations[0].Line == 99 || result.Sources()[0].Label != "metadata.yml" || result.Diagnostics() != nil {
|
|
t.Fatal("result inspection aliases internal records")
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsUnavailableOptionsAndDisabledDirectives(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type config struct {
|
|
Name string `yaml:"name"`
|
|
}
|
|
validSource := func() Source { return Bytes("options.yml", []byte("name: value\n")) }
|
|
tests := []struct {
|
|
name string
|
|
source Source
|
|
options []Options[config]
|
|
code Code
|
|
}{
|
|
{name: "multiple options", source: validSource(), options: []Options[config]{{}, {}}, code: CodeOptionsInvalid},
|
|
{name: "imports without filesystem context", source: validSource(), options: []Options[config]{{Imports: true}}, code: CodeOptionsInvalid},
|
|
{name: "incomplete filesystem", source: validSource(), options: []Options[config]{{Filesystem: &FilesystemContext{}}}, code: CodeOptionsInvalid},
|
|
{name: "missing version checker", source: validSource(), options: []Options[config]{{Definition: Definition[config]{Version: &VersionRule{Path: Keys("version")}}}}, code: CodeOptionsInvalid},
|
|
{name: "no-source filesystem", source: NoSource(), options: []Options[config]{{Filesystem: &FilesystemContext{}}}, code: CodeOptionsInvalid},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := Load(test.source, test.options...)
|
|
if result != nil || err == nil {
|
|
t.Fatalf("result, err = %#v, %v", result, err)
|
|
}
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) || len(loadError.Diagnostics()) == 0 || loadError.Diagnostics()[0].Code != test.code {
|
|
t.Fatalf("error = %#v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
result, err := Load[config](Bytes("directive.yml", []byte("nested:\n configkit: {}\n")))
|
|
if result != nil || err == nil {
|
|
t.Fatalf("result, err = %#v, %v", result, err)
|
|
}
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) {
|
|
t.Fatal(err)
|
|
}
|
|
diagnostic := loadError.Diagnostics()[0]
|
|
if diagnostic.Code != CodeImportDisabled || diagnostic.Path.String() != "/nested/configkit" || diagnostic.Primary == nil || diagnostic.Primary.Line != 2 {
|
|
t.Fatalf("diagnostic = %#v", diagnostic)
|
|
}
|
|
}
|
|
|
|
func TestLoadReturnsNilForSourceSchemaAndDecodeFailures(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
type invalidSchema struct {
|
|
Channel chan int `yaml:"channel"`
|
|
}
|
|
type validConfig struct {
|
|
Known int `yaml:"known"`
|
|
}
|
|
tests := []struct {
|
|
name string
|
|
run func() (any, error)
|
|
code Code
|
|
}{
|
|
{name: "source", run: func() (any, error) { return Load[validConfig](File(filepath.Join(t.TempDir(), "missing.yml"))) }, code: CodeSourceMissing},
|
|
{name: "schema", run: func() (any, error) { return Load[invalidSchema](Bytes("schema.yml", []byte("{}\n"))) }, code: CodeSchemaUnsupportedType},
|
|
{name: "decode", run: func() (any, error) { return Load[validConfig](Bytes("decode.yml", []byte("unknown: 1\n"))) }, code: CodeDecodeUnknownField},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := test.run()
|
|
if !isNilInterface(result) || err == nil {
|
|
t.Fatalf("result, err = %#v, %v", result, err)
|
|
}
|
|
var loadError *LoadError
|
|
if !errors.As(err, &loadError) || len(loadError.Diagnostics()) != 1 || loadError.Diagnostics()[0].Code != test.code {
|
|
t.Fatalf("error = %#v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func isNilInterface(value any) bool {
|
|
if value == nil {
|
|
return true
|
|
}
|
|
reflected := reflect.ValueOf(value)
|
|
return reflected.Kind() == reflect.Pointer && reflected.IsNil()
|
|
}
|