From 649a63fff1f47fa9a4e9f1a9e57caa0491e60bb4 Mon Sep 17 00:00:00 2001 From: Eric Rakestraw Date: Wed, 18 Nov 2026 00:47:56 +0000 Subject: [PATCH] Verify captured imports and layered companions --- docs/roadmap/implementation.md | 2 + internal/engine/prepared_imports_test.go | 121 +++++++++++++++++++++++ 2 files changed, 123 insertions(+) create mode 100644 internal/engine/prepared_imports_test.go diff --git a/docs/roadmap/implementation.md b/docs/roadmap/implementation.md index 33debe4..5e8de8d 100644 --- a/docs/roadmap/implementation.md +++ b/docs/roadmap/implementation.md @@ -259,6 +259,8 @@ existing access boundaries without retaining an open handle in the source. ## Stage 5 — Integrate imports and layered main-relative consumers +**Completed.** + Work in `import_acquisition.go`, `load_request.go`, and layered/context owners identified by the shared acquisition handoff. diff --git a/internal/engine/prepared_imports_test.go b/internal/engine/prepared_imports_test.go new file mode 100644 index 0000000..349745f --- /dev/null +++ b/internal/engine/prepared_imports_test.go @@ -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) + } +}