95 lines
3.7 KiB
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)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|