436 lines
15 KiB
Go
436 lines
15 KiB
Go
package config
|
|
|
|
import (
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"testing"
|
|
|
|
configkit "gitea.maximumdirect.net/eric/ConfigKit"
|
|
)
|
|
|
|
func TestPipelineInheritancePreservesCompositionAndReplacesSteps(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
tests := []struct {
|
|
name string
|
|
childSteps string
|
|
wantStepIDs []string
|
|
}{
|
|
{
|
|
name: "inherits ordered steps",
|
|
wantStepIDs: []string{"prepare", "summarize"},
|
|
},
|
|
{
|
|
name: "replaces ordered steps",
|
|
childSteps: `
|
|
steps:
|
|
- id: replacement
|
|
artifacts:
|
|
summary:
|
|
extract: {module: extract}`,
|
|
wantStepIDs: []string{"replacement"},
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
source := `version: 5
|
|
pipelines:
|
|
parent:
|
|
input: {module: input}
|
|
structured_output_repair_attempts: 2
|
|
steps:
|
|
- id: prepare
|
|
artifacts:
|
|
score:
|
|
extract: {module: extract, retries: 2}
|
|
- id: summarize
|
|
artifacts:
|
|
notes:
|
|
extract: {module: extract}
|
|
child:
|
|
extends: parent
|
|
llm_profile: local
|
|
structured_output_repair_attempts: 0` + test.childSteps + "\n"
|
|
loaded, err := loadConfigSource(configkit.Bytes("inheritance.yml", []byte(source)), LoadOptions{})
|
|
if err != nil {
|
|
t.Fatalf("loadConfigSource() error = %v", err)
|
|
}
|
|
|
|
parent := loaded.Config.Pipelines["parent"]
|
|
child := loaded.Config.Pipelines["child"]
|
|
if parent.Input.Module != "input" || child.Input.Module != "input" {
|
|
t.Fatalf("parent/child inputs = %#v / %#v", parent.Input, child.Input)
|
|
}
|
|
if child.LLMProfile != "local" ||
|
|
child.StructuredOutputRepairAttempts == nil || *child.StructuredOutputRepairAttempts != 0 {
|
|
t.Fatalf("child overrides = %#v", child)
|
|
}
|
|
if parent.StructuredOutputRepairAttempts == nil || *parent.StructuredOutputRepairAttempts != 2 {
|
|
t.Fatalf("parent settings changed: %#v", parent)
|
|
}
|
|
if len(child.Steps) != len(test.wantStepIDs) {
|
|
t.Fatalf("child steps = %#v, want %v", child.Steps, test.wantStepIDs)
|
|
}
|
|
for i, want := range test.wantStepIDs {
|
|
if child.Steps[i].ID != want {
|
|
t.Fatalf("child step %d = %q, want %q", i, child.Steps[i].ID, want)
|
|
}
|
|
}
|
|
if test.childSteps == "" && child.Steps[0].Artifacts["score"].Extract.Module != "extract" {
|
|
t.Fatalf("inherited first artifact = %#v", child.Steps[0].Artifacts["score"])
|
|
}
|
|
|
|
for _, id := range []string{"parent", "child"} {
|
|
resolved, err := loaded.Config.Resolve(ResolveInput{PipelineID: id, Catalog: effectiveCatalog(t)})
|
|
if err != nil {
|
|
t.Fatalf("Resolve(%q) error = %v", id, err)
|
|
}
|
|
if resolved.ResolvedPipeline.ID != id {
|
|
t.Fatalf("resolved pipeline ID = %q, want %q", resolved.ResolvedPipeline.ID, id)
|
|
}
|
|
wantResolvedSteps := len(test.wantStepIDs)
|
|
if id == "parent" {
|
|
wantResolvedSteps = 2
|
|
}
|
|
if len(resolved.ResolvedPipeline.Steps) != wantResolvedSteps {
|
|
t.Fatalf("resolved %q steps = %#v", id, resolved.ResolvedPipeline.Steps)
|
|
}
|
|
if id == "child" && resolved.ResolvedPipeline.Steps[0].ArtifactLanes[0].Extract.LLMProfile != "local" {
|
|
t.Fatalf("resolved child profile = %q", resolved.ResolvedPipeline.Steps[0].ArtifactLanes[0].Extract.LLMProfile)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestArtifactLaneInheritanceUsesSiblingMappingComposition(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
loaded, err := loadConfigSource(configkit.Bytes("lanes.yml", []byte(`version: 5
|
|
pipelines:
|
|
session:
|
|
input: {module: input}
|
|
artifacts:
|
|
base:
|
|
extract: {module: extract, retries: 2}
|
|
derived:
|
|
extends: base
|
|
extract: {retries: 4}
|
|
`)), LoadOptions{})
|
|
if err != nil {
|
|
t.Fatalf("loadConfigSource() error = %v", err)
|
|
}
|
|
|
|
lanes := loaded.Config.Pipelines["session"].Artifacts
|
|
if lanes["base"].Extract.Module != "extract" || lanes["base"].Extract.Retries != 2 {
|
|
t.Fatalf("base lane = %#v", lanes["base"])
|
|
}
|
|
if lanes["derived"].Extract.Module != "extract" || lanes["derived"].Extract.Retries != 4 {
|
|
t.Fatalf("derived lane = %#v", lanes["derived"])
|
|
}
|
|
if _, err := loaded.Config.Resolve(ResolveInput{PipelineID: "session", Catalog: effectiveCatalog(t)}); err != nil {
|
|
t.Fatalf("Resolve() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestInheritedPresenceOverridesRemainExplicit(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
loaded, err := loadConfigSource(configkit.Bytes("presence.yml", []byte(`version: 5
|
|
pipelines:
|
|
parent:
|
|
input: {module: input}
|
|
structured_output_repair_attempts: 3
|
|
chunk:
|
|
module: generic
|
|
validators: []
|
|
artifacts:
|
|
score:
|
|
extract:
|
|
module: extract
|
|
validators: [{module: configured-a}]
|
|
child:
|
|
extends: parent
|
|
structured_output_repair_attempts: 0
|
|
artifacts:
|
|
score:
|
|
extract:
|
|
validators: []
|
|
`)), LoadOptions{})
|
|
if err != nil {
|
|
var loadError *configkit.LoadError
|
|
if errors.As(err, &loadError) {
|
|
t.Fatalf("loadConfigSource() diagnostics = %#v", loadError.Diagnostics())
|
|
}
|
|
t.Fatalf("loadConfigSource() error = %v", err)
|
|
}
|
|
|
|
parent := loaded.Config.Pipelines["parent"]
|
|
child := loaded.Config.Pipelines["child"]
|
|
if parent.Chunk.Module != "generic" || !parent.Chunk.Validators.Set || parent.Chunk.Validators.Validators == nil || len(parent.Chunk.Validators.Validators) != 0 {
|
|
t.Fatalf("parent empty chunk validators = %#v", parent.Chunk)
|
|
}
|
|
if !parent.Artifacts["score"].Extract.Validators.Set || len(parent.Artifacts["score"].Extract.Validators.Validators) != 1 ||
|
|
parent.Artifacts["score"].Extract.Validators.Validators[0].Module != "configured-a" {
|
|
t.Fatalf("parent extraction validators = %#v", parent.Artifacts["score"].Extract.Validators)
|
|
}
|
|
if parent.StructuredOutputRepairAttempts == nil || *parent.StructuredOutputRepairAttempts != 3 {
|
|
t.Fatalf("parent repair budget = %#v", parent.StructuredOutputRepairAttempts)
|
|
}
|
|
if child.StructuredOutputRepairAttempts == nil || *child.StructuredOutputRepairAttempts != 0 {
|
|
t.Fatalf("child zero repair budget = %#v", child.StructuredOutputRepairAttempts)
|
|
}
|
|
extract := child.Artifacts["score"].Extract
|
|
if !extract.Validators.Set || extract.Validators.Validators == nil || len(extract.Validators.Validators) != 0 {
|
|
t.Fatalf("child empty extraction validators = %#v", extract.Validators)
|
|
}
|
|
if !child.Chunk.Validators.Set || child.Chunk.Validators.Validators == nil || len(child.Chunk.Validators.Validators) != 0 {
|
|
t.Fatalf("inherited empty chunk validators = %#v", child.Chunk.Validators)
|
|
}
|
|
|
|
resolved, err := loaded.Config.Resolve(ResolveInput{PipelineID: "child", Catalog: effectiveCatalog(t)})
|
|
if err != nil {
|
|
t.Fatalf("Resolve(child) error = %v", err)
|
|
}
|
|
lanes := resolved.ResolvedPipeline.AllArtifactLanes()
|
|
if len(lanes) != 1 || lanes[0].Extract.StructuredOutputRepairAttempts == nil || *lanes[0].Extract.StructuredOutputRepairAttempts != 0 {
|
|
t.Fatalf("resolved child repair budget = %#v", lanes)
|
|
}
|
|
if !resolved.ResolvedPipeline.Chunk.Validators.Set || len(resolved.ResolvedPipeline.Chunk.Validators.Validators) != 0 ||
|
|
!lanes[0].Extract.Validators.Set || len(lanes[0].Extract.Validators.Validators) != 0 {
|
|
t.Fatalf("resolved empty validator overrides = chunk %#v, extraction %#v", resolved.ResolvedPipeline.Chunk.Validators, lanes[0].Extract.Validators)
|
|
}
|
|
}
|
|
|
|
func TestInheritedFalseOptionRetainsExplicitMetadata(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
loaded, err := loadConfigSource(configkit.Bytes("false-option.yml", []byte(`version: 5
|
|
pipelines:
|
|
parent:
|
|
input: {module: input}
|
|
output:
|
|
module: json
|
|
options:
|
|
evidence_context: {enabled: false}
|
|
child:
|
|
extends: parent
|
|
`)), LoadOptions{})
|
|
if err != nil {
|
|
t.Fatalf("loadConfigSource() error = %v", err)
|
|
}
|
|
options := loaded.Config.Pipelines["child"].Output.Options["evidence_context"].(map[string]any)
|
|
if enabled, ok := options["enabled"].(bool); !ok || enabled {
|
|
t.Fatalf("inherited evidence_context.enabled = %#v", options["enabled"])
|
|
}
|
|
path := configkit.Keys("pipelines", "child", "output", "options", "evidence_context", "enabled")
|
|
info, ok := loaded.result.Metadata().Lookup(path)
|
|
if !ok || !info.Explicit || info.Null || len(info.Origin.Inheritance) == 0 {
|
|
t.Fatalf("inherited false metadata = %#v, found=%v", info, ok)
|
|
}
|
|
}
|
|
|
|
func TestInheritedAndDirectNullRepairBudgetsRemainInvalid(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, test := range []struct {
|
|
name string
|
|
source string
|
|
path string
|
|
}{
|
|
{
|
|
name: "child null",
|
|
source: `version: 5
|
|
pipelines:
|
|
parent: {input: {module: input}, structured_output_repair_attempts: 2}
|
|
child:
|
|
extends: parent
|
|
structured_output_repair_attempts: null
|
|
`,
|
|
path: "/pipelines/child/structured_output_repair_attempts",
|
|
},
|
|
{
|
|
name: "inherited null",
|
|
source: `version: 5
|
|
pipelines:
|
|
parent: {input: {module: input}, structured_output_repair_attempts: null}
|
|
child: {extends: parent}
|
|
`,
|
|
path: "/pipelines/parent/structured_output_repair_attempts",
|
|
},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
_, err := loadConfigSource(configkit.Bytes("null.yml", []byte(test.source)), LoadOptions{})
|
|
assertDocumentDiagnosticAt(t, err, test.path)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestOverlayAndOverridesComposeBeforeInheritance(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
root := t.TempDir()
|
|
overlays := filepath.Join(root, "overlays")
|
|
if err := os.MkdirAll(overlays, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
main := filepath.Join(root, "config.yml")
|
|
if err := os.WriteFile(main, []byte(`version: 5
|
|
pipelines:
|
|
parent:
|
|
input: {module: input}
|
|
structured_output_repair_attempts: 1
|
|
inherited:
|
|
extends: parent
|
|
overridden:
|
|
extends: parent
|
|
structured_output_repair_attempts: 0
|
|
cancelled:
|
|
extends: parent
|
|
input: {module: input}
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(overlays, "development.yml"), []byte(`pipelines:
|
|
parent:
|
|
structured_output_repair_attempts: 2
|
|
cancelled:
|
|
extends: null
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
loaded, err := Load(main, LoadOptions{Overlay: "development"})
|
|
if err != nil {
|
|
t.Fatalf("Load() error = %v", err)
|
|
}
|
|
if got := *loaded.Config.Pipelines["inherited"].StructuredOutputRepairAttempts; got != 2 {
|
|
t.Fatalf("overlay-inherited repair budget = %d, want 2", got)
|
|
}
|
|
if got := *loaded.Config.Pipelines["overridden"].StructuredOutputRepairAttempts; got != 0 {
|
|
t.Fatalf("child replacement repair budget = %d, want 0", got)
|
|
}
|
|
if loaded.Config.Pipelines["cancelled"].StructuredOutputRepairAttempts != nil {
|
|
t.Fatalf("cancelled child inherited parent settings: %#v", loaded.Config.Pipelines["cancelled"])
|
|
}
|
|
|
|
withOverride, err := Load(main, LoadOptions{
|
|
Overlay: "development",
|
|
Overrides: []configkit.Override{{
|
|
Path: configkit.Keys("pipelines", "parent", "structured_output_repair_attempts"),
|
|
Value: 3,
|
|
Flag: "--repair-budget",
|
|
}},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Load() with explicit override error = %v", err)
|
|
}
|
|
if got := *withOverride.Config.Pipelines["inherited"].StructuredOutputRepairAttempts; got != 3 {
|
|
t.Fatalf("override-inherited repair budget = %d, want 3", got)
|
|
}
|
|
}
|
|
|
|
func TestInheritedReferencePathsKeepDeclaringSource(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
root := t.TempDir()
|
|
parentDirectory := filepath.Join(root, "parents")
|
|
childDirectory := filepath.Join(root, "children")
|
|
overlayDirectory := filepath.Join(root, "overlays")
|
|
fixtureDirectory := filepath.Join(root, "fixtures")
|
|
for _, directory := range []string{parentDirectory, childDirectory, overlayDirectory, fixtureDirectory} {
|
|
if err := os.MkdirAll(directory, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
for _, name := range []string{"shared.txt", "parent.txt", "child.txt", "step.txt", "overlay.txt"} {
|
|
if err := os.WriteFile(filepath.Join(fixtureDirectory, name), []byte("fixture\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
parent := filepath.Join(parentDirectory, "pipelines.yml")
|
|
if err := os.WriteFile(parent, []byte(`pipelines:
|
|
" parent ":
|
|
input: {module: input}
|
|
references:
|
|
" shared ": {path: ../fixtures/shared.txt}
|
|
nested:
|
|
extends: " shared "
|
|
source: {path: ../fixtures/parent.txt}
|
|
steps:
|
|
- id: first
|
|
references:
|
|
step-source: {path: ../fixtures/step.txt}
|
|
artifacts:
|
|
summary:
|
|
extract: {module: extract}
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
child := filepath.Join(childDirectory, "pipelines.yml")
|
|
if err := os.WriteFile(child, []byte(`pipelines:
|
|
child:
|
|
extends: " parent "
|
|
references:
|
|
source: {path: ../fixtures/child.txt}
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
main := filepath.Join(root, "notarius.yml")
|
|
if err := os.WriteFile(main, []byte(`version: 5
|
|
configkit:
|
|
imports:
|
|
- path: parents/pipelines.yml
|
|
- path: children/pipelines.yml
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(overlayDirectory, "development.yml"), []byte(`pipelines:
|
|
" parent ":
|
|
references:
|
|
" shared ": {path: ../fixtures/overlay.txt}
|
|
`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
loaded, err := loadConfig(main, LoadOptions{})
|
|
if err != nil {
|
|
t.Fatalf("loadConfig() error = %v", err)
|
|
}
|
|
assertReferencePath := func(pipelineID, referenceID, want string) {
|
|
t.Helper()
|
|
if got := loaded.Config.Pipelines[pipelineID].References[referenceID].Path; got != want {
|
|
t.Errorf("%s reference %s path = %q, want %q", pipelineID, referenceID, got, want)
|
|
}
|
|
}
|
|
assertReferencePath("parent", "shared", filepath.Join(fixtureDirectory, "shared.txt"))
|
|
assertReferencePath("child", "shared", filepath.Join(fixtureDirectory, "shared.txt"))
|
|
assertReferencePath("child", "nested", filepath.Join(fixtureDirectory, "shared.txt"))
|
|
assertReferencePath("parent", "source", filepath.Join(fixtureDirectory, "parent.txt"))
|
|
assertReferencePath("child", "source", filepath.Join(fixtureDirectory, "child.txt"))
|
|
if got := loaded.Config.Pipelines["child"].Steps[0].References["step-source"].Path; got != filepath.Join(fixtureDirectory, "step.txt") {
|
|
t.Errorf("inherited step reference path = %q", got)
|
|
}
|
|
|
|
overlaid, err := loadConfig(main, LoadOptions{Overlay: "development"})
|
|
if err != nil {
|
|
t.Fatalf("loadConfig() with overlay error = %v", err)
|
|
}
|
|
for _, pipelineID := range []string{"parent", "child"} {
|
|
for _, referenceID := range []string{"shared", "nested"} {
|
|
if got, want := overlaid.Config.Pipelines[pipelineID].References[referenceID].Path, filepath.Join(fixtureDirectory, "overlay.txt"); got != want {
|
|
t.Errorf("overlaid %s reference %s path = %q, want %q", pipelineID, referenceID, got, want)
|
|
}
|
|
}
|
|
}
|
|
if got, want := overlaid.Config.Pipelines["child"].References["source"].Path, filepath.Join(fixtureDirectory, "child.txt"); got != want {
|
|
t.Errorf("child replacement path = %q, want %q", got, want)
|
|
}
|
|
if got, want := overlaid.Config.Pipelines["child"].Steps[0].References["step-source"].Path, filepath.Join(fixtureDirectory, "step.txt"); got != want {
|
|
t.Errorf("overlaid inherited step reference path = %q, want %q", got, want)
|
|
}
|
|
}
|