Files
notarius/internal/framework/pipeline/module_test.go

191 lines
6.2 KiB
Go

package pipeline
import (
"reflect"
"strings"
"testing"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
func TestValidateModuleSpecRequiresSupportedExecutionClass(t *testing.T) {
for _, test := range []struct {
name string
class contracts.ExecutionClass
want string
}{
{name: "missing", want: "execution class"},
{name: "unsupported", class: "remote", want: "unsupported"},
{name: "deterministic", class: contracts.ExecutionClassDeterministic},
{name: "llm backed", class: contracts.ExecutionClassLLMBacked},
} {
t.Run(test.name, func(t *testing.T) {
spec := normalizeModuleSpec(ModuleSpec{Key: "module", Stage: StageChunk, ExecutionClass: test.class})
err := validateModuleSpec("chunker", StageChunk, spec)
if test.want == "" && err != nil {
t.Fatalf("validateModuleSpec() error = %v, want nil", err)
}
if test.want != "" && (err == nil || !strings.Contains(err.Error(), test.want)) {
t.Fatalf("validateModuleSpec() error = %v, want %q", err, test.want)
}
})
}
}
func TestModuleSpecRetainsDetachedStaticPromptDependencies(t *testing.T) {
const initial = "notarius/test.initial"
const correction = "notarius/test.correction"
prompts := []string{correction, initial}
registry := NewExtractorRegistry()
if err := RegisterExtractor(registry, ModuleSpec{Key: "producer", Stage: StageExtract, ExecutionClass: contracts.ExecutionClassLLMBacked, ArtifactKind: "test/value", Prompts: prompts}, func() (contracts.Extractor[collaborationValue], error) { return &collaborationProducer{}, nil }); err != nil {
t.Fatal(err)
}
prompts[0] = "changed"
spec, ok := registry.Spec("producer")
if !ok || !reflect.DeepEqual(spec.Prompts, []string{correction, initial}) {
t.Fatalf("static dependencies = %#v", spec.Prompts)
}
spec.Prompts[0] = "also changed"
again, _ := registry.Spec("producer")
if !reflect.DeepEqual(again.Prompts, []string{correction, initial}) {
t.Fatalf("registry declarations mutated: %#v", again.Prompts)
}
}
func TestValidatorSpecRetainsDetachedPromptDependencies(t *testing.T) {
prompts := []string{"notarius/assessment"}
registry := NewValidatorRegistry()
if err := RegisterTypedValidator(registry, "test/value", ValidatorSpec{Key: "assessment", ExecutionClass: contracts.ExecutionClassLLMBacked, Prompts: prompts}, func() (contracts.TypedValidator[collaborationValue], error) { return collaborationValidator{}, nil }); err != nil {
t.Fatal(err)
}
prompts[0] = "changed"
spec, ok := registry.Spec("assessment")
if !ok || !reflect.DeepEqual(spec.Prompts, []string{"notarius/assessment"}) {
t.Fatalf("validator dependencies = %#v", spec.Prompts)
}
spec.Prompts[0] = "also changed"
again, _ := registry.Spec("assessment")
if !reflect.DeepEqual(again.Prompts, []string{"notarius/assessment"}) {
t.Fatalf("validator declarations mutated: %#v", again.Prompts)
}
}
func TestValidateModuleSpecAllowsReferenceSlotsForEligibleStages(t *testing.T) {
tests := []struct {
name string
kind string
stage ModuleStage
}{
{name: "chunker", kind: "chunker", stage: StageChunk},
{name: "extractor", kind: "extractor", stage: StageExtract},
{name: "merger", kind: "merger", stage: StageMerge},
{name: "normalizer", kind: "normalizer", stage: StageNormalize},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
spec := normalizeModuleSpec(ModuleSpec{
Key: "module",
Stage: test.stage,
ExecutionClass: contracts.ExecutionClassDeterministic,
ReferenceSlots: []contracts.ReferenceSlot{
{Name: "roster", Description: "Character roster", MaxBytes: 1024},
},
})
err := validateModuleSpec(test.kind, test.stage, spec)
if err != nil {
t.Fatalf("validateModuleSpec() error = %v, want nil", err)
}
})
}
}
func TestValidateModuleSpecRejectsReferenceSlotsForIneligibleStages(t *testing.T) {
tests := []struct {
name string
kind string
stage ModuleStage
}{
{name: "input", kind: "input adapter", stage: StageInput},
{name: "validate", kind: "validator", stage: StageValidate},
{name: "output", kind: "output encoder", stage: StageOutput},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
spec := normalizeModuleSpec(ModuleSpec{
Key: "module",
Stage: test.stage,
ExecutionClass: contracts.ExecutionClassDeterministic,
ReferenceSlots: []contracts.ReferenceSlot{
{Name: "roster"},
},
})
err := validateModuleSpec(test.kind, test.stage, spec)
if err == nil {
t.Fatal("validateModuleSpec() error = nil, want error")
}
if !strings.Contains(err.Error(), "reference slots") {
t.Fatalf("validateModuleSpec() error = %q, want reference slots context", err.Error())
}
})
}
}
func TestValidateModuleSpecRejectsInvalidReferenceSlotsForEligibleStages(t *testing.T) {
invalidSlots := []struct {
name string
slots []contracts.ReferenceSlot
want string
}{
{
name: "empty name",
slots: []contracts.ReferenceSlot{{Name: " "}},
want: "name",
},
{
name: "duplicate name after trim",
slots: []contracts.ReferenceSlot{
{Name: "roster"},
{Name: " roster "},
},
want: "duplicated",
},
{
name: "negative max bytes",
slots: []contracts.ReferenceSlot{{Name: "roster", MaxBytes: -1}},
want: "max_bytes",
},
}
eligibleStages := []struct {
name string
kind string
stage ModuleStage
}{
{name: "chunk", kind: "chunker", stage: StageChunk},
{name: "extract", kind: "extractor", stage: StageExtract},
{name: "merge", kind: "merger", stage: StageMerge},
{name: "normalize", kind: "normalizer", stage: StageNormalize},
}
for _, stage := range eligibleStages {
for _, invalid := range invalidSlots {
t.Run(stage.name+"/"+invalid.name, func(t *testing.T) {
spec := normalizeModuleSpec(ModuleSpec{
Key: "module",
Stage: stage.stage,
ExecutionClass: contracts.ExecutionClassDeterministic,
ReferenceSlots: invalid.slots,
})
err := validateModuleSpec(stage.kind, stage.stage, spec)
if err == nil {
t.Fatal("validateModuleSpec() error = nil, want error")
}
if !strings.Contains(err.Error(), invalid.want) {
t.Fatalf("validateModuleSpec() error = %q, want %q", err.Error(), invalid.want)
}
})
}
}
}