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) } } }