base-layer/configkit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Verify main-relative loading and evidence

Browse Source
This commit is contained in:
Eric Rakestraw
2026-11-09 20:44:32 +00:00
parent 08ea01921b
commit bc3fc91296
4 changed files with 210 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/roadmap/implementation.md
View File

@@ -210,6 +210,8 @@ No change to Audita or PromptKit is needed.
## Stage 7 — Close remaining integration and evidence gaps
**Status:** Complete. Focused discovery, source evidence, version, optional-resource, budget, and cleanup checks passed.
Fill remaining public integration gaps without repeating every engine test:
first and later search candidates, explicit file and mapping/bytes/reader
sources, only the file, only the directory, both, neither and an empty

40
examples/consumers/main_relative_test.go
View File

@@ -44,3 +44,43 @@ func TestMainRelativeStrictPeers(t *testing.T) {
}
t.Fatalf("diagnostics = %#v", err.(*configkit.LoadError).Diagnostics())
}
func TestMainRelativeOptionalResources(t *testing.T) {
for _, tc := range []struct {
name string
file, directory, empty bool
count int
}{
{"neither", false, false, false, 2}, {"file", true, false, false, 3},
{"directory", false, true, false, 3}, {"both", true, true, false, 4}, {"empty directory", false, false, true, 2},
} {
t.Run(tc.name, func(t *testing.T) {
root := t.TempDir()
if err := os.WriteFile(filepath.Join(root, "main.yml"), []byte("mode: main\n"), 0600); err != nil {
t.Fatal(err)
}
if tc.file {
if err := os.WriteFile(filepath.Join(root, "prompts.yml"), []byte("id: file\ntext: file\n"), 0600); err != nil {
t.Fatal(err)
}
}
if tc.directory || tc.empty {
if err := os.Mkdir(filepath.Join(root, "operator"), 0700); err != nil {
t.Fatal(err)
}
}
if tc.directory {
if err := os.WriteFile(filepath.Join(root, "operator", "item.yaml"), []byte("id: directory\ntext: directory\n"), 0600); err != nil {
t.Fatal(err)
}
}
result, err := consumers.LoadCompanionConfig(filepath.Join(root, "main.yml"), "")
if err != nil {
t.Fatalf("%v: %#v", err, err.(*configkit.LoadError).Diagnostics())
}
if len(result.Config.Prompts) != tc.count {
t.Fatalf("prompts = %#v", result.Config.Prompts)
}
})
}
}

124
facade_main_relative_integration_test.go Normal file
View File

@@ -0,0 +1,124 @@
package configkit_test
import (
"os"
"path/filepath"
"strings"
"testing"
configkit "go.maximumdirect.net/configkit"
)
func TestMainRelativeDiscoveryAndEvidence(t *testing.T) {
root := t.TempDir()
first, second := filepath.Join(root, "first"), filepath.Join(root, "second")
for _, dir := range []string{first, second} {
if err := os.MkdirAll(dir, 0700); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "main.yml"), []byte("count: 1\n"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "fragment.yml"), []byte("settings: {selected: "+filepath.Base(dir)+"}\n"), 0600); err != nil {
t.Fatal(err)
}
}
binding := configkit.MainRelative()
underlay := configkit.Input{Source: configkit.Bytes("declaration", []byte("config: {imports: [{path: fragment.yml}]}\n")), Imports: true, MainRelative: binding}
for _, test := range []struct {
name string
paths []string
want string
}{
{"first", []string{filepath.Join(first, "main.yml"), filepath.Join(second, "main.yml")}, "first"},
{"later", []string{filepath.Join(root, "missing.yml"), filepath.Join(second, "main.yml")}, "second"},
} {
t.Run(test.name, func(t *testing.T) {
var callbacks int
result, err := configkit.LoadLayered(configkit.Input{Source: configkit.SearchConfig("", configkit.SearchPaths(test.paths...))}, configkit.LayeredOptions[layeredFacadeConfig]{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{underlay}}}, Definition: configkit.Definition[layeredFacadeConfig]{Validate: func(*layeredFacadeConfig, *configkit.Validation) { callbacks++ }}})
if err != nil {
t.Fatalf("%v: %#v", err, err.(*configkit.LoadError).Diagnostics())
}
if result.Config.Settings["selected"] != test.want || callbacks != 1 {
t.Fatalf("config = %#v, callbacks = %d", result.Config, callbacks)
}
sources := result.Sources()
if len(sources) != 3 || sources[0].Layer != configkit.LayerMain || sources[1].Layer != configkit.LayerUnderlay || sources[2].Layer != configkit.LayerUnderlay || sources[2].UnderlayIndex != 1 || filepath.Base(sources[2].Path) != "fragment.yml" || sources[1].Path != "" {
t.Fatalf("sources = %#v", sources)
}
if _, ok := result.SourceContext(sources[1].ID); !ok {
t.Fatal("bound synthetic source lacks context")
}
if _, ok := result.SourceContext(sources[2].ID); !ok {
t.Fatal("import source lacks context")
}
})
}
}
func TestMainRelativeSyntheticMainContexts(t *testing.T) {
root := t.TempDir()
if err := os.WriteFile(filepath.Join(root, "fragment.yml"), []byte("settings: {selected: synthetic}\n"), 0600); err != nil {
t.Fatal(err)
}
ctx := &configkit.FilesystemContext{Root: root, BaseDir: root}
mainSources := []configkit.Source{configkit.Bytes("main bytes", []byte("count: 1\n")), configkit.Reader("main reader", strings.NewReader("count: 1\n")), configkit.Mapping("main mapping", map[string]any{"count": 1})}
for _, source := range mainSources {
input := configkit.Input{Source: configkit.Bytes("underlay", []byte("config: {imports: [{path: fragment.yml}]}\n")), Imports: true, MainRelative: configkit.MainRelative()}
result, err := configkit.LoadLayered(configkit.Input{Source: source, Filesystem: ctx}, configkit.LayeredOptions[layeredFacadeConfig]{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{input}}}})
if err != nil {
t.Fatalf("%v: %#v", err, err.(*configkit.LoadError).Diagnostics())
}
if result.Config.Settings["selected"] != "synthetic" {
t.Fatalf("config = %#v", result.Config)
}
}
}
func TestMainRelativeSelectedMainFailureIsTerminal(t *testing.T) {
root := t.TempDir()
bad, good := filepath.Join(root, "bad.yml"), filepath.Join(root, "good.yml")
if err := os.WriteFile(bad, []byte("count: [\n"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(good, []byte("count: 1\n"), 0600); err != nil {
t.Fatal(err)
}
called := false
input := configkit.Input{Source: configkit.Bytes("underlay", []byte("count: 3\n")), MainRelative: &configkit.MainRelativeContext{Fallback: &configkit.FilesystemContext{Root: root, BaseDir: root}}}
_, err := configkit.LoadLayered(configkit.Input{Source: configkit.SearchConfig("", configkit.SearchPaths(bad, good))}, configkit.LayeredOptions[layeredFacadeConfig]{Underlays: []configkit.Underlay{{Inputs: []configkit.Input{input}}}, Definition: configkit.Definition[layeredFacadeConfig]{Validate: func(*layeredFacadeConfig, *configkit.Validation) { called = true }}})
if err == nil || called {
t.Fatalf("error = %v, callback = %v", err, called)
}
}
func TestMainRelativeSourceVersionEvidence(t *testing.T) {
root := t.TempDir()
if err := os.WriteFile(filepath.Join(root, "main.yml"), []byte("version: 1\ncount: 1\n"), 0600); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(root, "fragment.yml"), []byte("version: 2\nsettings: {loaded: fragment}\n"), 0600); err != nil {
t.Fatal(err)
}
input := configkit.Input{Source: configkit.Bytes("companion", []byte("version: 3\nconfig: {imports: [{path: fragment.yml}]}\n")), Imports: true, MainRelative: configkit.MainRelative()}
type versioned struct {
Version int `yaml:"version"`
Count int `yaml:"count"`
Settings map[string]string `yaml:"settings"`
}
definition := configkit.Definition[versioned]{Version: &configkit.VersionRule{Path: configkit.Keys("version"), Check: func(configkit.Version, *configkit.Validation) error { return nil }}}
result, err := configkit.LoadLayered(configkit.Input{Source: configkit.File(filepath.Join(root, "main.yml"))}, configkit.LayeredOptions[versioned]{Definition: definition, SourceVersionMode: configkit.SourceVersionModeRequired, Underlays: []configkit.Underlay{{Inputs: []configkit.Input{input}}}})
if err != nil {
t.Fatalf("%v: %#v", err, err.(*configkit.LoadError).Diagnostics())
}
sources := result.Sources()
if len(sources) != 3 {
t.Fatalf("sources = %#v", sources)
}
for i, want := range []string{"1", "3", "2"} {
evidence := sources[i].VersionEvidence
if evidence == nil || evidence.Version.Text != want || evidence.Location == nil || evidence.Location.SourceID != sources[i].ID {
t.Fatalf("version evidence = %#v", sources)
}
}
}

44
internal/engine/main_relative_integration_test.go Normal file
View File

@@ -0,0 +1,44 @@
package engine
import (
"testing"
"testing/fstest"
)
func TestMainRelativeAcquisitionClosesHandlesOnFailure(t *testing.T) {
for _, fail := range []string{"parse", "read"} {
t.Run(fail, func(t *testing.T) {
body := "items: [invalid\n"
if fail == "read" {
body = "items: {key: value}\n"
}
filesystem := &observedFilesystem{files: fstest.MapFS{"dir/main.yml": {Data: []byte("{}\n")}, "dir/child.yml": {Data: []byte(body)}}}
if fail == "read" {
filesystem.failRead = "dir/child.yml"
}
namespace := newNativeNamespace("bundle", filesystem)
main := Input{Source: filesystemFile(namespace, "dir/main.yml")}
underlay := Input{Source: Bytes("declarations", []byte("config: {imports: [{path: child.yml}]}\n")), Imports: true, MainRelative: &MainRelativeContext{}}
_, err := LoadLayered[importTestConfig](main, SecretBinding{}, LayeredOptions[importTestConfig]{Underlays: []Underlay{{Inputs: []Input{underlay}}}})
if err == nil {
t.Fatal("invalid selected child succeeded")
}
filesystem.assertClosed(t)
})
}
}
func TestMainRelativeSharesAcquisitionBudget(t *testing.T) {
limits := defaultImportLimits()
limits.sources = 1
accounting := &importAccounting{}
state := &acquisitionState{accounting: accounting}
group := loadGroup{inputs: []loadInput{
{source: Bytes("one", []byte("items: {one: value}\n")), mainRelative: &MainRelativeContext{}},
{source: Bytes("two", []byte("items: {two: value}\n")), imports: true, mainRelative: &MainRelativeContext{}},
}}
_, diagnostics := acquireUnderlayGroupScopes(group, 1, nil, state, acquisitionPolicy{importLimits: limits}, nil)
if len(diagnostics) == 0 || diagnostics[0].Code != CodeImportLimitExceeded {
t.Fatalf("diagnostics = %#v", diagnostics)
}
}