111 lines
5.0 KiB
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)
|
|
}
|
|
}
|