331 lines
14 KiB
Go
331 lines
14 KiB
Go
package pipeline
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
)
|
|
|
|
type observedNotesCodec struct {
|
|
candidateValues []codecNotes
|
|
candidateDecodedValues []codecNotes
|
|
finalValues []codecNotes
|
|
candidateError string
|
|
candidateDecodeError string
|
|
finalError string
|
|
}
|
|
|
|
func (*observedNotesCodec) Kind() contracts.ArtifactKind { return "test/notes" }
|
|
|
|
func (*observedNotesCodec) Schema() contracts.ArtifactSchema { return notesCodec().schema }
|
|
|
|
func (*observedNotesCodec) MediaType() string { return "application/json" }
|
|
|
|
func (c *observedNotesCodec) EncodeCandidate(value codecNotes) ([]byte, error) {
|
|
c.candidateValues = append(c.candidateValues, value)
|
|
if c.candidateError != "" && firstNote(value) == c.candidateError {
|
|
return nil, errors.New("candidate encoding failed")
|
|
}
|
|
return json.Marshal(value)
|
|
}
|
|
|
|
func (c *observedNotesCodec) Encode(value codecNotes) ([]byte, error) {
|
|
c.finalValues = append(c.finalValues, value)
|
|
if c.finalError != "" && firstNote(value) == c.finalError {
|
|
return nil, errors.New("final encoding failed")
|
|
}
|
|
if firstNote(value) == "invalid" {
|
|
return nil, errors.New("invalid note is not a final artifact")
|
|
}
|
|
return json.Marshal(value)
|
|
}
|
|
|
|
func (*observedNotesCodec) Decode(content []byte) (codecNotes, error) {
|
|
var value codecNotes
|
|
return value, json.Unmarshal(content, &value)
|
|
}
|
|
|
|
func (c *observedNotesCodec) DecodeCandidate(content []byte) (codecNotes, error) {
|
|
value, err := c.Decode(content)
|
|
if err != nil {
|
|
return codecNotes{}, err
|
|
}
|
|
if c.candidateDecodeError != "" && firstNote(value) == c.candidateDecodeError {
|
|
return codecNotes{}, errors.New("candidate decoding failed")
|
|
}
|
|
c.candidateDecodedValues = append(c.candidateDecodedValues, value)
|
|
return value, nil
|
|
}
|
|
|
|
func firstNote(value codecNotes) string {
|
|
if len(value.Items) == 0 {
|
|
return ""
|
|
}
|
|
return value.Items[0]
|
|
}
|
|
|
|
func (c *observedNotesCodec) candidateCalls(value string) int {
|
|
return matchingNotes(c.candidateValues, value)
|
|
}
|
|
|
|
func (c *observedNotesCodec) finalCalls(value string) int {
|
|
return matchingNotes(c.finalValues, value)
|
|
}
|
|
|
|
func (c *observedNotesCodec) candidateDecodeCount() int {
|
|
return len(c.candidateDecodedValues)
|
|
}
|
|
|
|
func matchingNotes(values []codecNotes, value string) int {
|
|
count := 0
|
|
for _, candidate := range values {
|
|
if firstNote(candidate) == value {
|
|
count++
|
|
}
|
|
}
|
|
return count
|
|
}
|
|
|
|
func installObservedNotesCodec(t *testing.T, prepared *PreparedPipeline, codec *observedNotesCodec) {
|
|
t.Helper()
|
|
registry := NewArtifactCodecRegistry()
|
|
if err := RegisterArtifactCodec(registry, codec); err != nil {
|
|
t.Fatalf("RegisterArtifactCodec() error = %v", err)
|
|
}
|
|
entry, _, err := registry.entry("test/notes")
|
|
if err != nil {
|
|
t.Fatalf("codec entry error = %v", err)
|
|
}
|
|
prepared.Steps[0].lanes[0].typed.codec = entry
|
|
}
|
|
|
|
func configureCandidateOperation(prepared *PreparedPipeline, target ModuleStage, value codecNotes) {
|
|
lane := &prepared.Steps[0].lanes[0]
|
|
switch target {
|
|
case StageExtract:
|
|
lane.typed.extract = func(context.Context, any, contracts.TypedExtractionRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: value}, nil
|
|
}
|
|
lane.typed.merge = func(context.Context, any, contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"merged-other"}}}, nil
|
|
}
|
|
lane.typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"normalized-other"}}}, nil
|
|
}
|
|
case StageMerge:
|
|
lane.typed.merge = func(context.Context, any, contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: value}, nil
|
|
}
|
|
lane.typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"normalized-other"}}}, nil
|
|
}
|
|
case StageNormalize:
|
|
lane.typed.merge = func(context.Context, any, contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"merged-other"}}}, nil
|
|
}
|
|
lane.typed.normalize = func(context.Context, any, contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
|
|
return erasedTypedResult{Value: value}, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func setCandidateValidator(prepared *PreparedPipeline, target ModuleStage, approved bool) {
|
|
validator := preparedValidator{
|
|
resolved: ResolvedValidator{Binding: Binding("candidate-check"), Target: ValidatorTargetTyped, ArtifactKind: "test/notes"},
|
|
typedValidate: func(context.Context, any, typedValidationTarget) (contracts.ValidationResult, error) {
|
|
return contracts.ValidationResult{Approved: approved, ReasonCode: "candidate_rejected", Message: "candidate rejected by validator", CorrectionGuidance: "return an acceptable candidate"}, nil
|
|
},
|
|
}
|
|
switch target {
|
|
case StageExtract:
|
|
prepared.Steps[0].lanes[0].extractValidators.validators = []preparedValidator{validator}
|
|
case StageMerge:
|
|
prepared.Steps[0].lanes[0].mergeValidators.validators = []preparedValidator{validator}
|
|
case StageNormalize:
|
|
prepared.Steps[0].lanes[0].normalizeValidators.validators = []preparedValidator{validator}
|
|
}
|
|
}
|
|
|
|
func TestRunnerIsolatesTypedValidatorCandidates(t *testing.T) {
|
|
for _, target := range []ModuleStage{StageExtract, StageMerge, StageNormalize} {
|
|
t.Run(string(target), func(t *testing.T) {
|
|
prepared := preparedConcurrentPipeline(t, 1)
|
|
prepared.Steps[0].lanes[0].extractValidators = preparedValidatorChain{}
|
|
prepared.Steps[0].lanes[0].mergeValidators = preparedValidatorChain{}
|
|
prepared.Steps[0].lanes[0].normalizeValidators = preparedValidatorChain{}
|
|
codec := &observedNotesCodec{}
|
|
installObservedNotesCodec(t, prepared, codec)
|
|
candidate := codecNotes{Items: []string{"candidate-" + string(target)}, Labels: map[string]string{"label": "original"}, Details: &codecNoteDetails{Name: "original"}}
|
|
configureCandidateOperation(prepared, target, candidate)
|
|
|
|
var laterValue, serializedValue, downstreamValue codecNotes
|
|
firstValidator := preparedValidator{
|
|
resolved: ResolvedValidator{Binding: Binding("candidate-mutator"), Target: ValidatorTargetTyped, ArtifactKind: "test/notes"},
|
|
typedValidate: func(_ context.Context, _ any, request typedValidationTarget) (contracts.ValidationResult, error) {
|
|
value := request.value.(codecNotes)
|
|
value.Items[0] = "mutated"
|
|
value.Labels["label"] = "mutated"
|
|
value.Details.Name = "mutated"
|
|
return contracts.ValidationResult{Approved: true}, nil
|
|
},
|
|
}
|
|
secondValidator := preparedValidator{
|
|
resolved: ResolvedValidator{Binding: Binding("candidate-observer"), Target: ValidatorTargetTyped, ArtifactKind: "test/notes"},
|
|
typedValidate: func(_ context.Context, _ any, request typedValidationTarget) (contracts.ValidationResult, error) {
|
|
laterValue = request.value.(codecNotes)
|
|
return contracts.ValidationResult{Approved: true}, nil
|
|
},
|
|
}
|
|
serializedValidator := preparedValidator{
|
|
resolved: ResolvedValidator{Binding: Binding("candidate-serialized"), Target: ValidatorTargetSerialized, ArtifactKind: "test/notes"},
|
|
serialized: serializedValidationFunc(func(_ context.Context, request contracts.SerializedValidationRequest) (contracts.ValidationResult, error) {
|
|
if err := json.Unmarshal(request.Content, &serializedValue); err != nil {
|
|
return contracts.ValidationResult{}, err
|
|
}
|
|
return contracts.ValidationResult{Approved: true}, nil
|
|
}),
|
|
}
|
|
setCandidateValidators(prepared, target, []preparedValidator{firstValidator, secondValidator, serializedValidator})
|
|
|
|
lane := &prepared.Steps[0].lanes[0]
|
|
switch target {
|
|
case StageExtract:
|
|
lane.typed.merge = func(_ context.Context, _ any, request contracts.TypedMergeRequest[any]) (erasedTypedResult, error) {
|
|
downstreamValue = request.ExtractOutputs[0].Value.(codecNotes)
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"merged-other"}}}, nil
|
|
}
|
|
case StageMerge:
|
|
lane.typed.normalize = func(_ context.Context, _ any, request contracts.TypedNormalizeRequest[any]) (erasedTypedResult, error) {
|
|
downstreamValue = request.MergeOutput.Value.(codecNotes)
|
|
return erasedTypedResult{Value: codecNotes{Items: []string{"normalized-other"}}}, nil
|
|
}
|
|
}
|
|
|
|
output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")})
|
|
if err != nil {
|
|
t.Fatalf("Run() error = %v, want nil", err)
|
|
}
|
|
if !reflect.DeepEqual(laterValue, candidate) || !reflect.DeepEqual(serializedValue, candidate) {
|
|
t.Fatalf("validator values = typed %#v serialized %#v, want %#v", laterValue, serializedValue, candidate)
|
|
}
|
|
if codec.candidateCalls(candidate.Items[0]) != 1 || codec.candidateDecodeCount() != 2 || codec.finalCalls(candidate.Items[0]) != 1 {
|
|
t.Fatalf("candidate calls = encode %d decode %d final %d, want 1, 2, 1", codec.candidateCalls(candidate.Items[0]), codec.candidateDecodeCount(), codec.finalCalls(candidate.Items[0]))
|
|
}
|
|
switch target {
|
|
case StageExtract, StageMerge:
|
|
if !reflect.DeepEqual(downstreamValue, candidate) {
|
|
t.Fatalf("downstream value = %#v, want %#v", downstreamValue, candidate)
|
|
}
|
|
case StageNormalize:
|
|
var normalized codecNotes
|
|
if err := json.Unmarshal(output.normalizeOutputs[0].Artifact.Content, &normalized); err != nil || !reflect.DeepEqual(normalized, candidate) {
|
|
t.Fatalf("normalized output = %#v, %v; want %#v", normalized, err, candidate)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func setCandidateValidators(prepared *PreparedPipeline, target ModuleStage, validators []preparedValidator) {
|
|
switch target {
|
|
case StageExtract:
|
|
prepared.Steps[0].lanes[0].extractValidators.validators = validators
|
|
case StageMerge:
|
|
prepared.Steps[0].lanes[0].mergeValidators.validators = validators
|
|
case StageNormalize:
|
|
prepared.Steps[0].lanes[0].normalizeValidators.validators = validators
|
|
}
|
|
}
|
|
|
|
func TestRunnerReportsCandidateDecodeFailure(t *testing.T) {
|
|
prepared := preparedConcurrentPipeline(t, 1)
|
|
codec := &observedNotesCodec{candidateDecodeError: "decode-failure"}
|
|
installObservedNotesCodec(t, prepared, codec)
|
|
configureCandidateOperation(prepared, StageMerge, codecNotes{Items: []string{"decode-failure"}})
|
|
setCandidateValidator(prepared, StageMerge, true)
|
|
|
|
_, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")})
|
|
var codecErr *ArtifactCodecOperationError
|
|
if err == nil || !errors.As(err, &codecErr) || codecErr.Operation != "decode candidate" || codec.finalCalls("decode-failure") != 0 {
|
|
t.Fatalf("Run() error = %v, codec error = %#v, final calls = %d; want contextual candidate decode failure", err, codecErr, codec.finalCalls("decode-failure"))
|
|
}
|
|
}
|
|
|
|
func TestRunnerRejectsCandidatesBeforeFinalEncoding(t *testing.T) {
|
|
for _, target := range []ModuleStage{StageExtract, StageMerge, StageNormalize} {
|
|
t.Run(string(target), func(t *testing.T) {
|
|
prepared := preparedConcurrentPipeline(t, 1)
|
|
codec := &observedNotesCodec{}
|
|
installObservedNotesCodec(t, prepared, codec)
|
|
configureCandidateOperation(prepared, target, codecNotes{Items: []string{"invalid"}})
|
|
setCandidateValidator(prepared, target, false)
|
|
output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")})
|
|
if err == nil || !strings.Contains(err.Error(), "candidate-check") || len(output.OutputFiles) != 0 {
|
|
t.Fatalf("result=%#v error=%v, want rejection without publication", output, err)
|
|
}
|
|
if codec.candidateCalls("invalid") != 1 || codec.finalCalls("invalid") != 0 {
|
|
t.Fatalf("rejected candidate calls = candidate %d, final %d; want 1, 0", codec.candidateCalls("invalid"), codec.finalCalls("invalid"))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRunnerFinalEncodesAcceptedCandidatesOnce(t *testing.T) {
|
|
for _, target := range []ModuleStage{StageExtract, StageMerge, StageNormalize} {
|
|
t.Run(string(target), func(t *testing.T) {
|
|
prepared := preparedConcurrentPipeline(t, 1)
|
|
codec := &observedNotesCodec{}
|
|
installObservedNotesCodec(t, prepared, codec)
|
|
value := "accepted-" + string(target)
|
|
configureCandidateOperation(prepared, target, codecNotes{Items: []string{value}})
|
|
setCandidateValidator(prepared, target, true)
|
|
_, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if codec.candidateCalls(value) != 1 || codec.finalCalls(value) != 1 {
|
|
t.Fatalf("accepted candidate calls = candidate %d, final %d; want 1, 1", codec.candidateCalls(value), codec.finalCalls(value))
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRunnerReportsCandidateAndFinalEncodingFailures(t *testing.T) {
|
|
for _, target := range []ModuleStage{StageExtract, StageMerge, StageNormalize} {
|
|
for _, candidateFailure := range []bool{true, false} {
|
|
name := string(target) + "/final"
|
|
if candidateFailure {
|
|
name = string(target) + "/candidate"
|
|
}
|
|
t.Run(name, func(t *testing.T) {
|
|
prepared := preparedConcurrentPipeline(t, 1)
|
|
codec := &observedNotesCodec{}
|
|
value := "encoding-failure"
|
|
wantOperation := "encode"
|
|
if candidateFailure {
|
|
codec.candidateError = value
|
|
wantOperation = "encode candidate"
|
|
} else {
|
|
codec.finalError = value
|
|
}
|
|
installObservedNotesCodec(t, prepared, codec)
|
|
configureCandidateOperation(prepared, target, codecNotes{Items: []string{value}})
|
|
setCandidateValidator(prepared, target, true)
|
|
output, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")})
|
|
var codecErr *ArtifactCodecOperationError
|
|
if !errors.As(err, &codecErr) || codecErr.Operation != wantOperation || codecErr.Kind != "test/notes" || len(output.OutputFiles) != 0 {
|
|
t.Fatalf("output=%#v error=%v codec error=%#v, want scoped %s failure without publication", output, err, codecErr, wantOperation)
|
|
}
|
|
if candidateFailure && codec.finalCalls(value) != 0 {
|
|
t.Fatal("candidate failure reached final encoding")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|