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

235 lines
10 KiB
Go

package pipeline
import (
"context"
"encoding/json"
"fmt"
"reflect"
"strings"
"testing"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
func handoffFixture(t *testing.T, value codecNotes) (RunInput, PreparedPipelineStep, contracts.SerializedOutput) {
t.Helper()
prepared := preparedOrderedPipeline(t, 1,
orderedLaneSpec{id: "notes", profile: "notes"},
orderedLaneSpec{id: "score", profile: "score"},
)
consumer := &prepared.Steps[1].lanes[0]
installGeneratedTarget := func(target *ResolvedReferenceTarget, stage ModuleStage, module string) {
*target = ResolvedReferenceTarget{
Stage: stage,
StepID: consumer.resolved.StepID,
LaneID: consumer.resolved.ID,
Module: module,
Bindings: []ReferenceBinding{{
Stage: stage,
LaneID: consumer.resolved.ID,
SlotName: "producer-output",
Artifact: &ArtifactReference{Step: "step-1", Lane: "notes"},
}},
ReferenceSet: contracts.ReferenceSet{Slots: map[string]contracts.ResolvedReferenceSlot{
"producer-output": {Slot: contracts.ReferenceSlot{
Name: "producer-output",
AcceptedArtifactKinds: []contracts.ArtifactKind{"test/notes"},
AcceptedMediaTypes: []string{"application/json"},
}},
}},
}
}
installGeneratedTarget(&consumer.resolved.ExtractReferences, StageExtract, consumer.resolved.Extract.Module)
installGeneratedTarget(&consumer.resolved.MergeReferences, StageMerge, consumer.resolved.Merge.Module)
installGeneratedTarget(&consumer.resolved.NormalizeReferences, StageNormalize, consumer.resolved.Normalize.Module)
artifact, err := serializeArtifact(prepared.Steps[0].lanes[0].typed.codec, value, false)
if err != nil {
t.Fatalf("serializeArtifact() error = %v", err)
}
input := RunInput{Prepared: prepared}
input.pipeline = prepared.resolved
return input, prepared.Steps[1], contracts.SerializedOutput{
StepID: "step-1",
LaneID: "notes",
NormalizerKey: "typed/normalize",
SourceID: "source",
Artifact: contracts.CloneSerializedArtifact(artifact),
}
}
func TestBuildStepReferenceSetsCanonicalizesAndClonesFanout(t *testing.T) {
input, step, producerOutput := handoffFixture(t, codecNotes{Items: []string{"first"}})
sets, err := buildStepReferenceSets(input, step, []contracts.SerializedOutput{producerOutput})
if err != nil {
t.Fatalf("buildStepReferenceSets() error = %v", err)
}
if got, want := len(sets), 3; got != want {
t.Fatalf("reference target set count = %d, want %d", got, want)
}
var first []byte
for key, set := range sets {
item := set.Slots["producer-output"].Items[0]
if item.Origin.Type != "generated" || item.Origin.URI != "" {
t.Fatalf("target %v origin = %#v, want generated origin without URI", key, item.Origin)
}
if item.Producer.StepID != "step-1" || item.Producer.LaneID != "notes" || item.Producer.ModuleKey != "typed/normalize" {
t.Fatalf("target %v producer = %#v, want producer provenance", key, item.Producer)
}
if first == nil {
first = item.Content
continue
}
if &first[0] == &item.Content[0] {
t.Fatalf("target %v shares generated content backing storage", key)
}
}
if got := len(step.lanes[0].resolved.ExtractReferences.ReferenceSet.Slots["producer-output"].Items); got != 0 {
t.Fatalf("prepared extract reference items = %d, want zero", got)
}
}
func TestBuildStepReferenceSetsIndexesManyOutputsForFanout(t *testing.T) {
input, step, producerOutput := handoffFixture(t, codecNotes{Items: []string{"first"}})
outputs := make([]contracts.SerializedOutput, 0, 65)
for index := range 64 {
outputs = append(outputs, contracts.SerializedOutput{StepID: fmt.Sprintf("unrelated-step-%d", index), LaneID: "unrelated-lane"})
}
outputs = append(outputs, producerOutput)
sets, err := buildStepReferenceSets(input, step, outputs)
if err != nil {
t.Fatalf("buildStepReferenceSets() error = %v", err)
}
if len(sets) != 3 {
t.Fatalf("reference set count = %d, want 3", len(sets))
}
for target, set := range sets {
item := set.Slots["producer-output"].Items[0]
if item.Producer.StepID != "step-1" || item.Producer.LaneID != "notes" || string(item.Content) == "" {
t.Fatalf("target %v item = %#v, want canonical producer artifact", target, item)
}
}
}
func TestGeneratedReferenceAcceptsTypedEmptyCollection(t *testing.T) {
input, step, producerOutput := handoffFixture(t, codecNotes{})
sets, err := buildStepReferenceSets(input, step, []contracts.SerializedOutput{producerOutput})
if err != nil {
t.Fatalf("buildStepReferenceSets() error = %v, want nil for accepted empty collection", err)
}
if got := len(sets[keyForReferenceTarget(step.lanes[0].resolved.ExtractReferences)].Slots["producer-output"].Items); got != 1 {
t.Fatalf("generated empty collection item count = %d, want one artifact", got)
}
}
func TestGeneratedReferenceRejectsInvalidProducerOutputsDeterministically(t *testing.T) {
tests := []struct {
name string
outputs func(contracts.SerializedOutput) []contracts.SerializedOutput
mutate func(*ResolvedReferenceTarget, *contracts.SerializedOutput)
want string
}{
{name: "missing", outputs: func(contracts.SerializedOutput) []contracts.SerializedOutput { return nil }, want: "no accepted normalized output"},
{name: "multiple", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
return []contracts.SerializedOutput{output, output}
}, want: "exactly one is required"},
{name: "multiple after identifier normalization", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
duplicate := contracts.CloneSerializedOutput(output)
duplicate.StepID = " step-1 "
duplicate.LaneID = " notes "
return []contracts.SerializedOutput{output, duplicate}
}, want: "producer has 2 accepted normalized outputs; exactly one is required"},
{name: "kind mismatch", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
return []contracts.SerializedOutput{output}
}, mutate: func(target *ResolvedReferenceTarget, _ *contracts.SerializedOutput) {
target.ReferenceSet.Slots["producer-output"] = contracts.ResolvedReferenceSlot{Slot: contracts.ReferenceSlot{Name: "producer-output", AcceptedArtifactKinds: []contracts.ArtifactKind{"test/score"}}}
}, want: "does not accept artifact kind"},
{name: "schema mismatch", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
return []contracts.SerializedOutput{output}
}, mutate: func(_ *ResolvedReferenceTarget, output *contracts.SerializedOutput) {
output.Artifact.Schema.ID = "wrong.schema"
}, want: "schema identity"},
{name: "media mismatch", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
return []contracts.SerializedOutput{output}
}, mutate: func(_ *ResolvedReferenceTarget, output *contracts.SerializedOutput) {
output.Artifact.MediaType = "text/plain"
}, want: "media type"},
{name: "size mismatch", outputs: func(output contracts.SerializedOutput) []contracts.SerializedOutput {
return []contracts.SerializedOutput{output}
}, mutate: func(target *ResolvedReferenceTarget, _ *contracts.SerializedOutput) {
slot := target.ReferenceSet.Slots["producer-output"]
slot.Slot.MaxBytes = 1
target.ReferenceSet.Slots["producer-output"] = slot
}, want: "limit"},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
input, step, output := handoffFixture(t, codecNotes{Items: []string{"first"}})
output = contracts.CloneSerializedOutput(output)
if test.mutate != nil {
target := &step.lanes[0].resolved.ExtractReferences
test.mutate(target, &output)
}
_, err := buildStepReferenceSets(input, step, test.outputs(output))
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("buildStepReferenceSets() error = %v, want %q", err, test.want)
}
})
}
}
func BenchmarkIndexGeneratedOutputs(b *testing.B) {
outputs := make([]contracts.SerializedOutput, 0, 1024)
for index := range 1024 {
outputs = append(outputs, contracts.SerializedOutput{StepID: fmt.Sprintf("step-%d", index), LaneID: fmt.Sprintf("lane-%d", index)})
}
b.ResetTimer()
for range b.N {
_ = indexGeneratedOutputs(outputs)
}
}
func TestRunnerHandsOffAcceptedNormalizedOutputBeforeConsumerLanes(t *testing.T) {
input, _, _ := handoffFixture(t, codecNotes{Items: []string{"first"}})
prepared := input.Prepared
received := make(map[ModuleStage]contracts.ReferenceSet)
prepared.Steps[0].lanes[0].typed.extract = func(context.Context, any, contracts.TypedExtractionRequest[any]) (erasedTypedResult, error) {
return erasedTypedResult{Value: codecNotes{Items: []string{"first"}}}, nil
}
prepared.Steps[1].lanes[0].typed.extract = func(_ context.Context, _ any, request contracts.TypedExtractionRequest[any]) (erasedTypedResult, error) {
received[StageExtract] = CloneReferenceSet(request.References)
return erasedTypedResult{Value: codecScore{Value: 3}}, nil
}
prepared.Steps[0].lanes[0].typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
return erasedTypedResult{Value: codecNotes{Items: []string{"first"}}}, nil
}
prepared.Steps[1].lanes[0].typed.merge = func(_ context.Context, _ any, request contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
received[StageMerge] = CloneReferenceSet(request.References)
return erasedTypedResult{Value: codecScore{Value: 3}}, nil
}
prepared.Steps[1].lanes[0].typed.normalize = func(_ context.Context, _ any, request contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
received[StageNormalize] = CloneReferenceSet(request.References)
return erasedTypedResult{Value: codecScore{Value: 3}}, nil
}
_, err := New().Run(context.Background(), input)
if err != nil {
t.Fatalf("Run() error = %v", err)
}
for _, target := range []ModuleStage{StageExtract, StageMerge, StageNormalize} {
set, found := received[target]
if !found || len(set.Slots["producer-output"].Items) != 1 {
t.Fatalf("%s reference set = %#v, want producer artifact", target, set)
}
item := set.Slots["producer-output"].Items[0]
if item.Origin.Type != "generated" || item.Producer.StepID != "step-1" || item.Producer.LaneID != "notes" {
t.Fatalf("%s reference = %#v, want generated producer reference", target, item)
}
var value codecNotes
if err := json.Unmarshal(item.Content, &value); err != nil || !reflect.DeepEqual(value, codecNotes{Items: []string{"first"}}) {
t.Fatalf("%s reference value = %#v, %v", target, value, err)
}
}
}