Files
narratio/internal/app/runner_partial_result_test.go

95 lines
3.7 KiB
Go

package app
import (
"context"
"errors"
"testing"
"gitea.maximumdirect.net/eric/narratio/internal/adapters/whisperx"
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
"gitea.maximumdirect.net/eric/narratio/internal/stage"
)
type terminalCountingStore struct {
manifest.Store
terminalSaves int
terminalErr error
}
func (s *terminalCountingStore) Save(ctx context.Context, path string, m *manifest.Manifest) error {
if m.LastError != nil {
s.terminalSaves++
if s.terminalErr != nil {
return s.terminalErr
}
}
return s.Store.Save(ctx, path, m)
}
func TestPartialRunRetainsAllFailureCausesAndDurableSuccess(t *testing.T) {
for _, compositionFailure := range []bool{false, true} {
for _, saveFails := range []bool{false, true} {
t.Run(map[bool]string{false: "stage", true: "composition"}[compositionFailure]+map[bool]string{false: " saved", true: " save failed"}[saveFails], func(t *testing.T) {
cfg := testConfig(t)
cause := errors.New("operation unavailable")
saveErr := errors.New("terminal persistence unavailable")
releaseErr := errors.New("lock release failed")
store := &terminalCountingStore{Store: &manifest.LocalStore{}}
if saveFails {
store.terminalErr = saveErr
}
local := &releaseErrorArtifactStore{Store: artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root), err: releaseErr}
firstRuns := 0
stages := []stage.Stage{countingStage{name: "prepare", runs: &firstRuns}, failingStage{name: "transcribe", err: cause}, countingStage{name: "merge", runs: new(int)}}
deps := invocationDependencies{newWhisperX: func(*config.Config) (whisperx.Client, error) {
if compositionFailure {
return nil, cause
}
return &whisperx.NoopClient{}, nil
}}
summary, err := executePlanWithDependencies(context.Background(), cfg, BoundedPlan{stages: stages}, RunOptions{Env: &Env{ManifestStore: store, ArtifactStore: local}}, deps)
if !errors.Is(err, cause) || !errors.Is(err, releaseErr) || (saveFails && !errors.Is(err, saveErr)) {
t.Fatalf("lost causes: %v", err)
}
if store.terminalSaves != 1 {
t.Fatalf("terminal saves=%d", store.terminalSaves)
}
if summary == nil || summary.Complete || len(summary.StageResults) != 3 {
t.Fatalf("summary=%#v", summary)
}
if compositionFailure {
for _, result := range summary.StageResults {
if result.Attempted || result.Outcome != "not_attempted" {
t.Fatalf("composition scheduled work: %#v", summary)
}
}
return
}
if firstRuns != 1 || summary.StageResults[0].Outcome != "completed" || summary.StageResults[1].Outcome != "failed" || !summary.StageResults[1].Attempted || summary.StageResults[2].Outcome != "not_attempted" {
t.Fatalf("partial results=%#v", summary)
}
durable, err := store.Load(context.Background(), summary.ManifestPath)
if err != nil {
t.Fatal(err)
}
if durable.Stages["prepare"].Status != manifest.StatusSucceeded {
t.Fatal("earlier success lost")
}
if saveFails {
if durable.Stages["transcribe"].Status != manifest.StatusRunning {
t.Fatal("failed terminal save advertised durable failure")
}
} else if durable.Stages["transcribe"].Status != manifest.StatusFailed {
t.Fatal("failed attempt not persisted")
}
retry, err := executeStages(context.Background(), cfg, []stage.Stage{countingStage{name: "prepare", runs: &firstRuns}, countingStage{name: "transcribe", runs: new(int)}}, RunOptions{})
if err != nil || firstRuns != 1 || retry.StageResults[0].Outcome != "reused" || !retry.Complete {
t.Fatalf("retry=%#v runs=%d err=%v", retry, firstRuns, err)
}
})
}
}
}