285 lines
14 KiB
Go
285 lines
14 KiB
Go
package configkit_test
|
|
|
|
import (
|
|
"bytes"
|
|
"io/fs"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
"testing/fstest"
|
|
|
|
configkit "gitea.maximumdirect.net/eric/ConfigKit"
|
|
)
|
|
|
|
type inheritedEntry struct {
|
|
Enabled bool `yaml:"enabled"`
|
|
Count int `yaml:"count"`
|
|
Resource string `yaml:"resource"`
|
|
Settings map[string]map[string]string `yaml:"settings"`
|
|
}
|
|
|
|
type inheritedConfiguration struct {
|
|
Version string `yaml:"version"`
|
|
Entries map[string]inheritedEntry `yaml:"entries"`
|
|
}
|
|
|
|
func TestFacadeInheritancePreservesPresenceOriginsAndHistory(t *testing.T) {
|
|
input := []byte(`entries:
|
|
parent:
|
|
enabled: false
|
|
count: 0
|
|
settings:
|
|
primary: {value: original}
|
|
secondary: {extends: primary}
|
|
child:
|
|
extends: parent
|
|
settings:
|
|
primary: {value: custom}
|
|
`)
|
|
defaultRan := false
|
|
result, err := configkit.Load(configkit.Bytes("config.yml", input), configkit.Options[inheritedConfiguration]{Definition: configkit.Definition[inheritedConfiguration]{
|
|
Resolve: func(config *inheritedConfiguration, resolution *configkit.Resolution) error {
|
|
if !resolution.IsExplicit(configkit.Keys("entries", "child", "enabled")) {
|
|
t.Error("inherited false is not explicit")
|
|
}
|
|
info, found := resolution.InputInfo(configkit.Keys("entries", "child", "enabled"))
|
|
if !found || len(info.Origin.Inheritance) != 1 {
|
|
t.Errorf("resolver inherited origin = %#v, %v", info, found)
|
|
}
|
|
child := config.Entries["child"]
|
|
configkit.Default(resolution, configkit.Keys("entries", "child", "enabled"), &child.Enabled, true, "use fallback")
|
|
defaultRan = child.Enabled
|
|
config.Entries["child"] = child
|
|
return nil
|
|
},
|
|
}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
child := result.Config.Entries["child"]
|
|
if defaultRan || child.Enabled || child.Count != 0 || child.Settings["secondary"]["value"] != "custom" {
|
|
t.Fatalf("inherited values = %#v, default ran %v", child, defaultRan)
|
|
}
|
|
path := configkit.Keys("entries", "child", "settings", "secondary", "value")
|
|
info, found := result.Metadata().Lookup(path)
|
|
if !found || !info.Explicit || len(info.Origin.Inheritance) != 1 ||
|
|
info.Origin.Inheritance[0].From.String() != "/entries/child/settings/primary/value" ||
|
|
info.Origin.Inheritance[0].To.String() != path.String() {
|
|
t.Fatalf("nested destination origin = %#v, %v", info, found)
|
|
}
|
|
info.Origin.Inheritance[0].Locations[0].SourceID = "mutated"
|
|
info, _ = result.Metadata().Lookup(path)
|
|
if info.Origin.Inheritance[0].Locations[0].SourceID == "mutated" {
|
|
t.Fatal("public inheritance record aliases inspection state")
|
|
}
|
|
if _, found := result.Metadata().Lookup(configkit.Keys("entries", "child", "extends")); found {
|
|
t.Fatal("consumed directive remained effective")
|
|
}
|
|
control, found := result.Explain(configkit.Keys("entries", "child", "extends"))
|
|
if !found || control.Effective.Present || len(control.History) < 2 ||
|
|
control.History[len(control.History)-1].Origin.Operation != configkit.ChangeInheritance {
|
|
t.Fatalf("consumed directive = %#v, %v", control, found)
|
|
}
|
|
explanation, found := result.Explain(path)
|
|
if !found || explanation.Effective.YAML != "custom\n" {
|
|
t.Fatalf("nested explanation = %#v, %v", explanation, found)
|
|
}
|
|
for _, change := range explanation.History {
|
|
if change.Origin.Operation == configkit.ChangeDecoding {
|
|
t.Fatalf("inherited value attributed to decoding: %#v", explanation.History)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceLayeredPrecedenceAndSourceContext(t *testing.T) {
|
|
filesystem := configkit.NewFilesystem("bundle", fstest.MapFS{
|
|
"config/main.yml": &fstest.MapFile{Data: []byte("entries: {child: {extends: parent}}\n")},
|
|
"shared/parent.yml": &fstest.MapFile{Data: []byte("entries: {parent: {resource: icon.txt, count: 1}}\n")},
|
|
"shared/flags.yml": &fstest.MapFile{Data: []byte("entries: {parent: {enabled: false}}\n")},
|
|
"shared/icon.txt": &fstest.MapFile{Data: []byte("parent-resource")},
|
|
"config/overlays/test.yml": &fstest.MapFile{Data: []byte("entries: {parent: {count: 2}}\n")},
|
|
})
|
|
result, err := configkit.LoadLayered(configkit.Input{Source: filesystem.File("config/main.yml")}, configkit.LayeredOptions[inheritedConfiguration]{
|
|
Underlays: []configkit.Underlay{
|
|
{Inputs: []configkit.Input{{Source: filesystem.File("shared/parent.yml")}}},
|
|
{Inputs: []configkit.Input{{Source: filesystem.File("shared/flags.yml")}}},
|
|
},
|
|
Overlay: "test", OverlayFilesystem: &configkit.FilesystemContext{Root: "config", BaseDir: "config", FS: &filesystem},
|
|
Overrides: []configkit.Override{{Path: configkit.Keys("entries", "child", "count"), Value: 3, Flag: "--count"}},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
child := result.Config.Entries["child"]
|
|
if child.Count != 3 || child.Resource != "icon.txt" {
|
|
t.Fatalf("layered inheritance = %#v", child)
|
|
}
|
|
info, found := result.Metadata().Lookup(configkit.Keys("entries", "child", "resource"))
|
|
if !found || len(info.Origin.Inheritance) != 1 || len(info.Origin.Locations) != 1 {
|
|
t.Fatalf("resource origin = %#v, %v", info, found)
|
|
}
|
|
context, found := result.SourceContext(info.Origin.Locations[0].SourceID)
|
|
if !found || context.BaseDir != "shared" || context.FS == nil {
|
|
t.Fatalf("source context = %#v, %v", context, found)
|
|
}
|
|
data, err := fs.ReadFile(context.FS, context.BaseDir+"/"+child.Resource)
|
|
if err != nil || string(data) != "parent-resource" {
|
|
t.Fatalf("source-relative resource = %q, %v", data, err)
|
|
}
|
|
count, found := result.Metadata().Lookup(configkit.Keys("entries", "child", "count"))
|
|
if !found || count.Origin.Layer != configkit.LayerCLI || len(count.Origin.Inheritance) != 0 {
|
|
t.Fatalf("CLI replacement origin = %#v, %v", count, found)
|
|
}
|
|
var rendered bytes.Buffer
|
|
if err := result.WriteEffective(&rendered); err != nil || strings.Contains(rendered.String(), "extends:") {
|
|
t.Fatalf("effective rendering = %q, %v", rendered.String(), err)
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceMappingMatchesBytes(t *testing.T) {
|
|
values := map[string]any{"entries": map[string]any{
|
|
"parent": map[string]any{"enabled": false, "count": 0},
|
|
"child": map[string]any{"extends": "parent"},
|
|
}}
|
|
mapped, err := configkit.Load[inheritedConfiguration](configkit.Mapping("mapping", values))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fromYAML, err := configkit.Load[inheritedConfiguration](configkit.Bytes("config.yml", []byte("entries: {parent: {enabled: false, count: 0}, child: {extends: parent}}\n")))
|
|
if err != nil || !reflect.DeepEqual(mapped.Config, fromYAML.Config) {
|
|
t.Fatalf("mapping and bytes differ: %#v, %#v, %v", mapped, fromYAML, err)
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceProtectsVersionOwnership(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name, input string
|
|
path configkit.Path
|
|
wantFailure bool
|
|
}{
|
|
{"inherited version", "entries: {parent: {count: 1}, child: {extends: parent}}\n", configkit.Keys("entries", "child", "count"), true},
|
|
{"overridden version", "entries: {parent: {count: 1}, child: {extends: parent, count: 1}}\n", configkit.Keys("entries", "child", "count"), true},
|
|
{"direct unchanged version", "entries: {parent: {enabled: false}, child: {extends: parent, count: 1}}\n", configkit.Keys("entries", "child", "count"), false},
|
|
{"consumed checked directive", "entries: {parent: {count: 1}, child: {extends: parent}}\n", configkit.Keys("entries", "child", "extends"), true},
|
|
{"independent top-level version", "version: v1\nentries: {parent: {count: 1}, child: {extends: parent}}\n", configkit.Keys("version"), false},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
checks := struct{ version, defaults, resolution, validation int }{}
|
|
result, err := configkit.Load(configkit.Bytes("version.yml", []byte(test.input)), configkit.Options[inheritedConfiguration]{Definition: configkit.Definition[inheritedConfiguration]{
|
|
Version: &configkit.VersionRule{Path: test.path, Check: func(configkit.Version, *configkit.Validation) error {
|
|
checks.version++
|
|
return nil
|
|
}},
|
|
Defaults: func() inheritedConfiguration { checks.defaults++; return inheritedConfiguration{} },
|
|
Resolve: func(*inheritedConfiguration, *configkit.Resolution) error { checks.resolution++; return nil },
|
|
Validate: func(*inheritedConfiguration, *configkit.Validation) { checks.validation++ },
|
|
}})
|
|
if test.wantFailure {
|
|
if result != nil || err == nil {
|
|
t.Fatalf("protected version = %#v, %v", result, err)
|
|
}
|
|
loadError, ok := err.(*configkit.LoadError)
|
|
if !ok || len(loadError.Diagnostics()) == 0 || loadError.Diagnostics()[0].Code != configkit.CodeInheritanceVersion ||
|
|
checks != (struct{ version, defaults, resolution, validation int }{version: 1}) {
|
|
t.Fatalf("version failure = %v, callbacks %#v", err, checks)
|
|
}
|
|
} else if err != nil || result == nil || checks != (struct{ version, defaults, resolution, validation int }{1, 1, 1, 1}) {
|
|
t.Fatalf("unchanged version = %#v, %v, callbacks %#v", result, err, checks)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceFailureStopsLaterCallbacks(t *testing.T) {
|
|
checks := struct{ defaults, resolution, validation int }{}
|
|
result, err := configkit.Load(configkit.Bytes("invalid.yml", []byte("entries: {child: {extends: PRIVATE-REFERENCE-CANARY}}\n")), configkit.Options[inheritedConfiguration]{Definition: configkit.Definition[inheritedConfiguration]{
|
|
Defaults: func() inheritedConfiguration { checks.defaults++; return inheritedConfiguration{} },
|
|
Resolve: func(*inheritedConfiguration, *configkit.Resolution) error { checks.resolution++; return nil },
|
|
Validate: func(*inheritedConfiguration, *configkit.Validation) { checks.validation++ },
|
|
}})
|
|
if result != nil || err == nil || checks != (struct{ defaults, resolution, validation int }{}) || strings.Contains(err.Error(), "PRIVATE-REFERENCE-CANARY") {
|
|
t.Fatalf("invalid inheritance = %#v, %v, callbacks %#v", result, err, checks)
|
|
}
|
|
loadError, ok := err.(*configkit.LoadError)
|
|
if !ok || len(loadError.Diagnostics()) == 0 || loadError.Diagnostics()[0].Code != configkit.CodeInheritanceMissing {
|
|
t.Fatalf("missing reference diagnostics = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceResolvesAfterImportsAndCLIReferenceChange(t *testing.T) {
|
|
filesystem := configkit.NewFilesystem("bundle", fstest.MapFS{
|
|
"main.yml": &fstest.MapFile{Data: []byte("configkit: {imports: [{path: parent.yml}]}\nentries: {child: {extends: first}}\n")},
|
|
"parent.yml": &fstest.MapFile{Data: []byte("entries: {first: {count: 1}, second: {count: 2}}\n")},
|
|
})
|
|
result, err := configkit.Load(filesystem.File("main.yml"), configkit.Options[inheritedConfiguration]{
|
|
Imports: true, Overrides: []configkit.Override{{Path: configkit.Keys("entries", "child", "extends"), Value: "second", Flag: "--extends"}},
|
|
})
|
|
if err != nil || result.Config.Entries["child"].Count != 2 {
|
|
t.Fatalf("import and CLI reference = %#v, %v", result, err)
|
|
}
|
|
history := result.Metadata().History(configkit.Keys("entries", "child", "extends"))
|
|
if len(history) < 3 || history[len(history)-1].Origin.Operation != configkit.ChangeInheritance {
|
|
t.Fatalf("superseded reference history = %#v", history)
|
|
}
|
|
conflicting := configkit.NewFilesystem("bundle", fstest.MapFS{
|
|
"main.yml": &fstest.MapFile{Data: []byte("configkit: {imports: [{path: parent.yml}]}\nentries: {child: {extends: first}, first: {count: 3}}\n")},
|
|
"parent.yml": &fstest.MapFile{Data: []byte("entries: {first: {count: 1}}\n")},
|
|
})
|
|
_, err = configkit.Load[inheritedConfiguration](conflicting.File("main.yml"), configkit.Options[inheritedConfiguration]{Imports: true})
|
|
loadError, ok := err.(*configkit.LoadError)
|
|
if !ok || len(loadError.Diagnostics()) == 0 || loadError.Diagnostics()[0].Code != configkit.CodeComposeConflict {
|
|
t.Fatalf("strict conflict before expansion = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritanceSelectedOverlayCancelsRelationship(t *testing.T) {
|
|
filesystem := configkit.NewFilesystem("bundle", fstest.MapFS{
|
|
"main.yml": &fstest.MapFile{Data: []byte("entries: {parent: {count: 7}, child: {extends: parent, enabled: false}}\n")},
|
|
"overlays/test.yml": &fstest.MapFile{Data: []byte("entries: {child: {extends: null}}\n")},
|
|
})
|
|
result, err := configkit.Load(filesystem.File("main.yml"), configkit.Options[inheritedConfiguration]{
|
|
Overlay: "test", Filesystem: &configkit.FilesystemContext{Root: ".", FS: &filesystem},
|
|
})
|
|
if err != nil || result.Config.Entries["child"].Count != 0 || result.Config.Entries["child"].Enabled {
|
|
if loadError, ok := err.(*configkit.LoadError); ok {
|
|
t.Fatalf("cancelled relationship = %#v, %v, diagnostics %#v", result, err, loadError.Diagnostics())
|
|
}
|
|
t.Fatalf("cancelled relationship = %#v, %v", result, err)
|
|
}
|
|
history := result.Metadata().History(configkit.Keys("entries", "child", "extends"))
|
|
if len(history) < 3 || history[len(history)-1].Origin.Operation != configkit.ChangeInheritance {
|
|
t.Fatalf("cancellation history = %#v", history)
|
|
}
|
|
}
|
|
|
|
func TestFacadeInheritedSecretsStayRedactedAfterLookup(t *testing.T) {
|
|
const canary = "INHERITED-RELEASE-TEST-CREDENTIAL"
|
|
t.Setenv("CONFIGKIT_INHERITED_TEST_SECRET", canary)
|
|
type entry struct {
|
|
Credential configkit.Secret `yaml:"credential"`
|
|
Plain string `yaml:"plain"`
|
|
}
|
|
type configuration struct {
|
|
Entries map[string]entry `yaml:"entries"`
|
|
}
|
|
result, err := configkit.Load[configuration](configkit.Bytes("secret.yml", []byte("entries: {parent: {credential: CONFIGKIT_INHERITED_TEST_SECRET, plain: visible}, child: {extends: parent}}\n")), configkit.Options[configuration]{Definition: configkit.Definition[configuration]{
|
|
Secret: func(path configkit.Path) bool { return path.String() == "/entries/parent/credential" },
|
|
}})
|
|
if err != nil || result.Config.Entries["child"].Credential.Value() != canary {
|
|
t.Fatalf("inherited credential = %#v, %v", result, err)
|
|
}
|
|
path := configkit.Keys("entries", "child", "credential")
|
|
explanation, found := result.Explain(path)
|
|
if !found || !explanation.Effective.Redacted || strings.Contains(explanation.Effective.YAML, canary) {
|
|
t.Fatalf("credential explanation = %#v, %v", explanation, found)
|
|
}
|
|
var rendered bytes.Buffer
|
|
if err := result.WriteEffective(&rendered); err != nil || strings.Contains(rendered.String(), canary) || !strings.Contains(rendered.String(), "visible") {
|
|
t.Fatalf("effective secret rendering = %q, %v", rendered.String(), err)
|
|
}
|
|
rendered.Reset()
|
|
if err := result.WriteExplanation(&rendered, path); err != nil || strings.Contains(rendered.String(), canary) {
|
|
t.Fatalf("historical secret rendering = %q, %v", rendered.String(), err)
|
|
}
|
|
}
|