Verify captured imports and layered companions

This commit is contained in:
2026-11-18 00:47:56 +00:00
parent e750b6d423
commit 649a63fff1
2 changed files with 123 additions and 0 deletions

View File

@@ -0,0 +1,121 @@
package engine
import (
"errors"
"os"
"path/filepath"
"testing"
)
func TestCapturedMainLoadsLiveImportsWithIndependentEvidence(t *testing.T) {
root := t.TempDir()
mainBody := "version: 1\nconfig: {imports: [{path: ../shared.yml}]}\nsettings: {main: captured}\n"
main := writeImportFile(t, root, "app/main.yml", mainBody)
child := writeImportFile(t, root, "shared.yml", "version: 2\nsettings: {child: original}\n")
prepared, _, diagnostics := captureHostMain(File(main), &FilesystemContext{Root: root})
if len(diagnostics) != 0 {
t.Fatal(diagnostics)
}
if err := os.WriteFile(main, []byte("settings: {main: changed}\n"), 0o600); err != nil {
t.Fatal(err)
}
type config struct {
Version int `yaml:"version"`
Settings map[string]string `yaml:"settings"`
}
options := Options[config]{Imports: true, SourceVersionMode: sourceVersionModeRequired,
Definition: Definition[config]{Version: &VersionRule{Path: Keys("version"), Check: func(Version, *Validation) error { return nil }}},
}
for _, value := range []string{"first", "second"} {
if err := os.WriteFile(child, []byte("version: 2\nsettings: {child: "+value+"}\n"), 0o600); err != nil {
t.Fatal(err)
}
loaded, err := testLoad(prepared, options)
if err != nil {
t.Fatal(err)
}
if loaded.Config.Settings["main"] != "captured" || loaded.Config.Settings["child"] != value {
t.Fatalf("configuration = %#v", loaded.Config)
}
sources := loaded.Sources()
if len(sources) != 2 || sources[0].ID != "source-1" || sources[1].ID != "source-2" || sources[0].VersionCheck == nil || sources[0].VersionCheck.Version.Text != "1" || sources[1].VersionCheck == nil || sources[1].VersionCheck.Version.Text != "2" {
t.Fatalf("source evidence = %#v", sources)
}
sources[0].Label = "mutated"
if loaded.Sources()[0].Label == "mutated" {
t.Fatal("source evidence aliases returned records")
}
}
}
func TestCapturedMainImportIdentityAndAccounting(t *testing.T) {
root := t.TempDir()
mainBody := "config: {imports: [{path: child.yml}]}\nsettings: {main: captured}\n"
childBody := "settings: {child: value}\n"
main := writeImportFile(t, root, "main.yml", mainBody)
child := writeImportFile(t, root, "child.yml", childBody)
prepared, _, diagnostics := captureHostMain(File(main), nil)
if len(diagnostics) != 0 {
t.Fatal(diagnostics)
}
accounting := &importAccounting{}
state := &acquisitionState{accounting: accounting}
policy := acquisitionPolicy{importLimits: defaultImportLimits()}
input, diagnostics := acquireInput(inputAcquisitionRequest{
input: loadInput{source: prepared, imports: true, destination: Keys("service")},
role: sourceVersionMain, directiveContext: rootDirectiveContextSource,
}, policy, state, &tierAcquisitionState{visited: make(map[resourceIdentity]importRoute)})
mainParsed, _ := parseSource(Bytes("main", []byte(mainBody)), "main", defaultParseLimits())
childParsed, _ := parseSource(Bytes("child", []byte(childBody)), "child", defaultParseLimits())
wantNodes := countInputNodes(mainParsed.document) + countInputNodes(childParsed.document) + destinationWrapperNodeCount(Keys("service"))*2
if len(diagnostics) != 0 || len(input.sources) != 2 || accounting.sources != 2 || accounting.bytes != int64(len(mainBody)+len(childBody)) || accounting.nodes != wantNodes {
t.Fatalf("acquisition = %#v, diagnostics = %#v, accounting = %#v, want nodes %d", input, diagnostics, accounting, wantNodes)
}
if err := os.WriteFile(child, []byte("config: {imports: [{path: main.yml}]}\n"), 0o600); err != nil {
t.Fatal(err)
}
requireLoadCode(t, prepared, Options[importTestConfig]{Imports: true}, CodeImportCycle)
if err := os.WriteFile(child, []byte("settings: {child: value}\n"), 0o600); err != nil {
t.Fatal(err)
}
_, err := LoadLayered(Input{Source: NoSource()}, testSecretBinding(), LayeredOptions[importTestConfig]{
Underlays: []Underlay{{Inputs: []Input{{Source: prepared, Imports: true}, {Source: prepared, Imports: true}}}},
})
var loadErr *LoadError
if !errors.As(err, &loadErr) || len(loadErr.Diagnostics()) == 0 || loadErr.Diagnostics()[0].Code != CodeImportRepeated {
t.Fatalf("repeated captured file: %v", err)
}
if err := os.WriteFile(main, []byte("changed: true\n"), 0o600); err != nil {
t.Fatal(err)
}
for range 2 {
if _, err := testLoad(prepared, Options[discoveryLoadConfig]{Imports: true}); err != nil {
t.Fatalf("independent load: %v", err)
}
}
}
func TestCapturedMainBindsLayeredCompanions(t *testing.T) {
root := t.TempDir()
main := writeImportFile(t, root, "app/main.yml", "settings: {main: yes-value}\n")
writeImportFile(t, root, "app/lower.yml", "settings: {lower: underlay}\n")
writeImportFile(t, root, "app/overlays/dev.yml", "settings: {selected: overlay}\n")
prepared, _, diagnostics := captureHostMain(File(main), &FilesystemContext{Root: root})
if len(diagnostics) != 0 {
t.Fatal(diagnostics)
}
underlay := Input{Source: Bytes("companion", []byte("config: {imports: [{path: lower.yml}]}\n")), Imports: true, MainRelative: &MainRelativeContext{RequireBase: true}}
loaded, err := LoadLayered(Input{Source: prepared}, testSecretBinding(), LayeredOptions[discoveryLoadConfig]{
Underlays: []Underlay{{Inputs: []Input{underlay}}}, Overlay: "dev",
})
if err != nil {
t.Fatal(err)
}
if loaded.Config.Settings["main"] != "yes-value" || loaded.Config.Settings["lower"] != "underlay" || loaded.Config.Settings["selected"] != "overlay" {
t.Fatalf("layered configuration = %#v", loaded.Config)
}
sources := loaded.Inspection.Sources()
if len(sources) != 4 || sources[0].Path != canonicalTestPath(t, main) || sources[2].Path != canonicalTestPath(t, filepath.Join(root, "app/lower.yml")) || sources[3].Layer != LayerOverlay {
t.Fatalf("layered sources = %#v", sources)
}
}