Files
narratio/internal/app/execution_command_test.go

208 lines
8.0 KiB
Go

package app
import (
"bytes"
"context"
"encoding/json"
"errors"
"gitea.maximumdirect.net/eric/narratio/internal/artifacts"
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
"gitea.maximumdirect.net/eric/narratio/internal/stage"
"reflect"
"strings"
"testing"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"go.maximumdirect.net/commandkit"
configkit "go.maximumdirect.net/configkit"
)
func TestExecutionCommandsUseTypedBoundedPlans(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
full, err := BuildBoundedPlan("", "")
if err != nil {
t.Fatal(err)
}
for _, test := range []struct {
name string
args, want []string
force bool
}{
{"full", []string{"run", "2026-05-03"}, full.Names(), false},
{"single", []string{"run", "2026-05-03", "--stage", "analyze"}, []string{"analyze"}, false},
{"forced single", []string{"run", "2026-05-03", "--stage", "publish", "--force"}, []string{"publish"}, true},
{"range", []string{"run", "2026-05-03", "--from", "extract", "--through", "analyze"}, []string{"extract", "analyze"}, false},
{"regenerate", []string{"artifacts", "regenerate", "2026-05-03"}, []string{"extract", "analyze"}, true},
} {
t.Run(test.name, func(t *testing.T) {
calls := 0
executor := func(_ context.Context, cfg *config.Config, plan BoundedPlan, options RunOptions) (*RunSummary, error) {
calls++
if !reflect.DeepEqual(plan.Names(), test.want) || options.Force != test.force {
t.Fatalf("plan=%v force=%v", plan.Names(), options.Force)
}
if cfg.Session.SessionID != "2026-05-03" || !options.EffectiveArtifacts.Resolved() {
t.Fatal("missing resolved execution inputs")
}
return &RunSummary{SessionID: cfg.Session.SessionID, RunID: "synthetic-run", Executed: plan.Names()}, nil
}
app, err := newApplication(commandDependencies{}, executor)
if err != nil {
t.Fatal(err)
}
args := append(append([]string{}, test.args...), "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json")
var out, diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic})
if outcome.Status != 0 || calls != 1 {
t.Fatalf("status=%d calls=%d diagnostics=%s", outcome.Status, calls, diagnostic.String())
}
var report runReport
if err := json.Unmarshal(out.Bytes(), &report); err != nil {
t.Fatal(err)
}
if !report.Complete || report.Campaign != "sample-campaign" || !reflect.DeepEqual(report.Executed, test.want) {
t.Fatalf("report=%#v", report)
}
})
}
}
func TestExecutionCommandsRejectInvalidSelectionBeforeBootstrap(t *testing.T) {
app, err := newApplication(commandDependencies{
loadSecretsDir: func(string) (*configkit.SecretsReport, error) {
t.Fatal("invalid input bootstrapped secrets")
return nil, nil
},
loadPipelineConfig: func(string, config.PipelineLoadOptions) (*config.PipelineConfig, error) {
t.Fatal("invalid input loaded config")
return nil, nil
},
}, func(context.Context, *config.Config, BoundedPlan, RunOptions) (*RunSummary, error) {
t.Fatal("invalid input executed pipeline")
return nil, nil
})
if err != nil {
t.Fatal(err)
}
for _, args := range [][]string{
{"run"}, {"run", "session", "--stage", "analyze", "--from", "analyze"},
{"run", "session", "--stage", "analyze", "--through", "analyze"},
{"run", "session", "--from", "publish", "--through", "prepare"},
{"run", "session", "--stage", "missing"},
{"run", "session", "--stage", "prepare", "--artifacts", "recap"},
{"artifacts", "regenerate", "session", "--force=false"},
{"artifacts", "regenerate", "session", "--through", "publish"},
{"run", "session", "--session-id", "session"},
{"run", "session", "--set", `/whisperx/language="fr"`},
{"run-stage", "analyze", "session"},
{"analyze", "session"},
{"publish", "session"},
{"regenerate-artifacts", "session"},
} {
var out, diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic})
if outcome.Status != 2 {
t.Fatalf("%v: status=%d diagnostics=%s", args, outcome.Status, diagnostic.String())
}
}
}
type releaseObservedStore struct {
artifacts.Store
released bool
}
func (s *releaseObservedStore) ReleaseSessionLock(lock *artifacts.LockHandle) error {
err := s.Store.ReleaseSessionLock(lock)
s.released = true
return err
}
type failingRunReportWriter struct {
t *testing.T
store *releaseObservedStore
err error
}
func (w failingRunReportWriter) Write([]byte) (int, error) {
if !w.store.released {
w.t.Fatal("report written before lock release")
}
return 0, w.err
}
func TestExecutionCommandReportFailurePreservesCompletedWork(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
writeErr := errors.New("report destination unavailable")
var saved *RunSummary
var local *releaseObservedStore
app, err := newApplication(commandDependencies{}, func(ctx context.Context, cfg *config.Config, _ BoundedPlan, opts RunOptions) (*RunSummary, error) {
local = &releaseObservedStore{Store: artifacts.NewLocalStore(cfg.Pipeline.Workspace.Root)}
opts.Env = &Env{ArtifactStore: local}
var err error
saved, err = executeStages(ctx, cfg, []stage.Stage{resultStage{name: "prepare"}}, opts)
return saved, err
})
if err != nil {
t.Fatal(err)
}
// Defer resolving the store until Report invokes Write.
writer := runReportWriteFunc(func(p []byte) (int, error) {
return (failingRunReportWriter{t: t, store: local, err: writeErr}).Write(p)
})
var diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), []string{"run", "2026-05-03", "--stage", "prepare", "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json"}, commandkit.Streams{Out: writer, Err: &diagnostic})
if outcome.Status != 1 || !errors.Is(outcome.Cause, writeErr) {
t.Fatalf("outcome=%#v diagnostics=%s", outcome, diagnostic.String())
}
if saved == nil || !saved.Complete {
t.Fatalf("completed domain result=%#v", saved)
}
durable, err := (&manifest.LocalStore{}).Load(context.Background(), saved.ManifestPath)
if err != nil {
t.Fatal(err)
}
if durable.Stages["prepare"].Status != manifest.StatusSucceeded || durable.LastError != nil {
t.Fatalf("report failure changed domain state: %#v", durable)
}
}
type runReportWriteFunc func([]byte) (int, error)
func (f runReportWriteFunc) Write(p []byte) (int, error) { return f(p) }
func TestExecutionCommandPresentsPartialFailureThroughNativeVisibility(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
cause := errors.New("synthetic terminal operation failure")
app, err := newApplication(commandDependencies{}, func(_ context.Context, cfg *config.Config, _ BoundedPlan, _ RunOptions) (*RunSummary, error) {
return &RunSummary{SessionID: cfg.Session.SessionID, RunID: "synthetic-run", Executed: []string{"prepare", "transcribe"}, StageResults: []RunStageResult{{Name: "prepare", Attempted: true, Outcome: "completed"}, {Name: "transcribe", Attempted: true, Outcome: "failed"}}}, cause
})
if err != nil {
t.Fatal(err)
}
for _, quiet := range []bool{false, true} {
args := []string{"run", "2026-05-03", "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json"}
if quiet {
args = append(args, "--quiet")
}
var out, diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic})
if outcome.Status != 1 || !errors.Is(outcome.Cause, cause) || strings.Count(diagnostic.String(), cause.Error()) != 1 {
t.Fatalf("outcome=%#v diagnostics=%s", outcome, diagnostic.String())
}
if quiet {
if out.Len() != 0 {
t.Fatal("quiet emitted a report")
}
continue
}
var report runReport
if err := json.Unmarshal(out.Bytes(), &report); err != nil {
t.Fatal(err)
}
if report.Complete || len(report.StageResults) != 2 || report.StageResults[1].Outcome != "failed" {
t.Fatalf("report=%#v", report)
}
}
}