Files
narratio/internal/app/command_reporting_test.go

174 lines
7.5 KiB
Go
Raw Normal View History

package app
import (
"bytes"
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"gitea.maximumdirect.net/eric/narratio/internal/config"
"gitea.maximumdirect.net/eric/narratio/internal/manifest"
"gitea.maximumdirect.net/eric/narratio/internal/stage"
"go.maximumdirect.net/commandkit"
)
type diagnosticStage struct {
result *stage.StageResult
err error
}
func (s diagnosticStage) Name() string { return "prepare" }
func (s diagnosticStage) Run(_ context.Context, env *stage.Env, _ *manifest.Manifest) (*stage.StageResult, error) {
env.Info("stage context")
env.Warn("stage warning")
env.Debug("stage diagnostic")
return s.result, s.err
}
func TestNativeConsoleVisibilityDoesNotChangeExecution(t *testing.T) {
for _, test := range []struct {
name string
flags []string
info, debug, progress, quiet bool
}{
{name: "ordinary"},
{name: "verbose", flags: []string{"--verbose"}, info: true},
{name: "progress", flags: []string{"--progress"}, progress: true},
{name: "verbose progress", flags: []string{"--verbose", "--progress"}, info: true, progress: true},
{name: "quiet", flags: []string{"--debug", "--progress", "--quiet"}, quiet: true},
{name: "debug", flags: []string{"--debug"}, info: true, debug: true, progress: true},
{name: "debug without progress", flags: []string{"--debug", "--progress=false"}, info: true, debug: true},
{name: "cleared debug", flags: []string{"--debug", "--debug=false"}},
{name: "last progress value", flags: []string{"--progress=false", "--progress=true"}, progress: true},
{name: "last mode", flags: []string{"--quiet", "--verbose"}, info: true},
} {
t.Run(test.name, func(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
logPath := filepath.Join(t.TempDir(), "captured.log")
const captured = "synthetic-private-downstream-output"
if err := os.WriteFile(logPath, []byte(captured), 0o600); err != nil {
t.Fatal(err)
}
var saved *RunSummary
app, err := newApplication(commandDependencies{}, func(ctx context.Context, cfg *config.Config, plan BoundedPlan, opts RunOptions) (*RunSummary, error) {
if len(plan.Names()) != 1 || plan.Names()[0] != "prepare" || opts.Force {
t.Fatal("console flags changed execution selection")
}
if cfg.Pipeline.Trim.Bounds.RenderDebug || (cfg.Pipeline.Scriptorium != nil && cfg.Pipeline.Scriptorium.RenderDebug) {
t.Fatal("console debug changed downstream capture")
}
var err error
saved, err = executeStages(ctx, cfg, []stage.Stage{diagnosticStage{result: &stage.StageResult{Logs: []string{logPath}}}}, opts)
return saved, err
})
if err != nil {
t.Fatal(err)
}
args := []string{"run", "2026-05-03", "--stage", "prepare", "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json"}
args = append(args, test.flags...)
var out, diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &diagnostic})
if outcome.Status != 0 || saved == nil || !saved.Complete {
t.Fatalf("outcome=%#v diagnostics=%s", outcome, diagnostic.String())
}
text := diagnostic.String()
for _, check := range []struct {
fragment string
want bool
}{{"stage context", test.info}, {"selected pipeline configuration", test.info}, {"stage warning", test.info}, {"stage diagnostic", test.debug}, {"manifest saved", test.debug}, {"starting stage", test.progress}, {"stage succeeded", test.progress}} {
if strings.Contains(text, check.fragment) != check.want {
t.Fatalf("visibility for %q = %v, want %v; diagnostics=%s", check.fragment, !check.want, check.want, text)
}
}
if strings.Contains(text+out.String(), captured) {
t.Fatal("replayed captured downstream output")
}
if test.quiet {
if out.Len() != 0 || diagnostic.Len() != 0 {
t.Fatal("quiet produced successful console output")
}
return
}
var report runReport
if err := json.Unmarshal(out.Bytes(), &report); err != nil {
t.Fatal(err)
}
if !report.Complete || len(report.StageResults) != 1 || report.StageResults[0].Outcome != "completed" {
t.Fatalf("report=%#v", report)
}
})
}
}
func TestNativeConsoleReportsSelfSkipReuseAndSingleFailure(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
cause := errors.New("synthetic stage failure")
for _, test := range []struct {
name string
selected stage.Stage
flags []string
want string
status int
}{
{name: "self skip", selected: diagnosticStage{result: &stage.StageResult{Disposition: stage.StageDispositionSkipped, SkipReason: "disabled"}}, flags: []string{"--progress"}, want: "stage skipped"},
{name: "success", selected: diagnosticStage{}, flags: []string{"--progress"}, want: "stage succeeded"},
{name: "reuse", selected: failingStage{name: "prepare", err: errors.New("must reuse")}, flags: []string{"--progress"}, want: "reusing stage"},
{name: "failure", selected: diagnosticStage{err: cause}, flags: []string{"--force", "--progress"}, status: 1},
{name: "quiet failure", selected: diagnosticStage{err: cause}, flags: []string{"--force", "--quiet"}, status: 1},
} {
t.Run(test.name, func(t *testing.T) {
app, err := newApplication(commandDependencies{}, func(ctx context.Context, cfg *config.Config, _ BoundedPlan, opts RunOptions) (*RunSummary, error) {
return executeStages(ctx, cfg, []stage.Stage{test.selected}, opts)
})
if err != nil {
t.Fatal(err)
}
args := []string{"run", "2026-05-03", "--stage", "prepare", "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--format", "json"}
var out, diagnostic bytes.Buffer
outcome := app.Execute(context.Background(), append(args, test.flags...), commandkit.Streams{Out: &out, Err: &diagnostic})
if outcome.Status != test.status {
t.Fatalf("outcome=%#v diagnostics=%s", outcome, diagnostic.String())
}
if test.status == 1 {
if strings.Count(diagnostic.String(), cause.Error()) != 1 {
t.Fatalf("failure presented repeatedly: %s", diagnostic.String())
}
return
}
if !strings.Contains(diagnostic.String(), test.want) {
t.Fatalf("missing %q: %s", test.want, diagnostic.String())
}
})
}
}
func TestNativeConsoleDeliveryFailureDoesNotInterruptCheckpointing(t *testing.T) {
pipeline, campaign, session := writeValidConfigFiles(t, t.TempDir())
writeErr := errors.New("diagnostic destination unavailable")
var saved *RunSummary
app, err := newApplication(commandDependencies{}, func(ctx context.Context, cfg *config.Config, _ BoundedPlan, opts RunOptions) (*RunSummary, error) {
var err error
saved, err = executeStages(ctx, cfg, []stage.Stage{diagnosticStage{}}, opts)
return saved, err
})
if err != nil {
t.Fatal(err)
}
var out bytes.Buffer
outcome := app.Execute(context.Background(), []string{"run", "2026-05-03", "--stage", "prepare", "--config", pipeline, "--campaign-file", campaign, "--session-file", session, "--progress", "--format", "json"}, commandkit.Streams{Out: &out, Err: runReportWriteFunc(func([]byte) (int, error) { return 0, writeErr })})
if outcome.Status != 1 || !errors.Is(outcome.Presentation.Diagnostics.WriteError, writeErr) || saved == nil || !saved.Complete {
t.Fatalf("outcome=%#v summary=%#v", outcome, saved)
}
durable, err := (&manifest.LocalStore{}).Load(context.Background(), saved.ManifestPath)
if err != nil {
t.Fatal(err)
}
if durable.Stages["prepare"].Status != manifest.StatusSucceeded {
t.Fatal("diagnostic delivery failure interrupted domain work")
}
}