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

111 lines
5.0 KiB
Go

package pipeline
import (
"context"
"errors"
"testing"
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
)
func TestProducerTerminalModeControlsSupportedFallback(t *testing.T) {
failure := errors.New("candidate not accepted")
for _, mode := range []contracts.ExecutionMode{contracts.ModeStrict, contracts.ModePermissive} {
calls := 0
value, outcome, err := FinishProducerFailure(context.Background(), mode, failure, func(context.Context) (string, error) { calls++; return "supported", nil })
if mode == contracts.ModeStrict {
if !errors.Is(err, failure) || calls != 0 || value != "" || outcome.Disposition != "" {
t.Fatalf("strict = %q %#v %v, calls %d", value, outcome, err, calls)
}
} else if err != nil || calls != 1 || value != "supported" || outcome.Disposition != contracts.ProducerFallback || outcome.ReuseEligible || outcome.FallbackReason == "" {
t.Fatalf("permissive = %q %#v %v, calls %d", value, outcome, err, calls)
}
}
}
func TestProducerFallbackCannotHideConstructionFailure(t *testing.T) {
original, construction := errors.New("original failure"), errors.New("no invariant-preserving fallback")
_, outcome, err := FinishProducerFailure(context.Background(), contracts.ModePermissive, original, func(context.Context) (string, error) { return "", construction })
if !errors.Is(err, original) || !errors.Is(err, construction) || outcome.Disposition != "" {
t.Fatalf("outcome = %#v, error = %v", outcome, err)
}
if _, _, err := FinishProducerFailure[string](context.Background(), contracts.ModePermissive, original, nil); !errors.Is(err, original) {
t.Fatalf("unsupported fallback = %v", err)
}
}
func TestProducerCancellationNeverDeliversFallback(t *testing.T) {
for _, cancelDuringFallback := range []bool{false, true} {
ctx, cancel := context.WithCancel(context.Background())
calls := 0
if !cancelDuringFallback {
cancel()
}
value, outcome, err := FinishProducerFailure(ctx, contracts.ModePermissive, errors.New("failure"), func(context.Context) (string, error) {
calls++
cancel()
return "not delivered", nil
})
cancel()
if !errors.Is(err, context.Canceled) || value != "" || outcome.Disposition != "" {
t.Fatalf("cancellation = %q %#v %v", value, outcome, err)
}
if !cancelDuringFallback && calls != 0 {
t.Fatal("fallback started after cancellation")
}
}
}
func TestProducerLocalTimeoutDoesNotBecomeCallerCancellation(t *testing.T) {
value, outcome, err := FinishProducerFailure(context.Background(), contracts.ModePermissive, context.DeadlineExceeded, func(context.Context) (string, error) { return "supported", nil })
if err != nil || value != "supported" || outcome.Disposition != contracts.ProducerFallback {
t.Fatalf("local timeout = %q %#v %v", value, outcome, err)
}
}
func TestNoModelProducerIsAssessedOnceWithoutRevalidatingFallback(t *testing.T) {
for _, approve := range []bool{true, false} {
for _, mode := range []contracts.ExecutionMode{contracts.ModeStrict, contracts.ModePermissive} {
assessed, fallbacks := 0, 0
operation := contracts.ProducerOperation[string]{
Controls: contracts.ProducerControls{Mode: mode}, ReuseEligible: true,
Assess: func(context.Context, string) (contracts.CandidateAssessment, error) {
assessed++
if approve {
return contracts.CandidateAssessment{}, nil
}
return contracts.CandidateAssessment{Validators: []contracts.ValidatorAssessment{{ValidatorName: "policy", Decision: contracts.AssessmentRejected, Result: contracts.ValidationResult{Message: "not accepted"}}}}, nil
},
}
value, outcome, err := AssessProducer(context.Background(), operation, "candidate", func(context.Context) (string, error) { fallbacks++; return "supported", nil })
if assessed != 1 {
t.Fatalf("assessed %d times", assessed)
}
if approve {
if err != nil || value != "candidate" || outcome.Disposition != contracts.ProducerAccepted || !outcome.ReuseEligible || fallbacks != 0 {
t.Fatalf("acceptance = %q %#v %v", value, outcome, err)
}
} else if mode == contracts.ModeStrict {
if err == nil || value != "" || outcome.Disposition != "" || fallbacks != 0 {
t.Fatalf("strict failure = %q %#v %v", value, outcome, err)
}
} else if err != nil || value != "supported" || outcome.Disposition != contracts.ProducerFallback || outcome.ReuseEligible || fallbacks != 1 {
t.Fatalf("fallback = %q %#v %v", value, outcome, err)
}
}
}
}
func TestNoModelProducerStopsAfterAssessmentCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
operation := contracts.ProducerOperation[int]{Controls: contracts.ProducerControls{Mode: contracts.ModePermissive},
Assess: func(context.Context, int) (contracts.CandidateAssessment, error) {
cancel()
return contracts.CandidateAssessment{}, nil
}}
_, outcome, err := AssessProducer(ctx, operation, 1, func(context.Context) (int, error) { t.Fatal("fallback after cancellation"); return 0, nil })
if !errors.Is(err, context.Canceled) || outcome.Disposition != "" {
t.Fatalf("cancellation = %#v %v", outcome, err)
}
}