package server import ( "context" "fmt" "os" "path/filepath" "strings" "testing" "git.a-wan.net/alan/pipelines/internal/pipeline" "git.a-wan.net/alan/pipelines/internal/protocol" "git.a-wan.net/alan/pipelines/internal/stage" "git.a-wan.net/alan/pipelines/internal/summarise" ) func TestRenderReportContract(t *testing.T) { for _, format := range []string{"html", "markdown"} { name, body, err := renderReport(format, map[string]any{"markdown": "# Report\n\n**Done**\n"}) if err != nil || name == "" || len(body) == 0 { t.Fatalf("%s: %s %v", format, body, err) } if format == "html" && (!strings.Contains(string(body), "

Report

") || strings.Contains(string(body), ""}) if string(again) != string(body) { t.Fatal("not deterministic") } } for _, output := range []map[string]any{nil, {}, {"markdown": " \n"}, {"files": []string{"report.html"}}, {"markdown": strings.Repeat("x", reportLimit+1)}} { if _, _, err := renderReport("html", output); err == nil { t.Fatalf("accepted absent/oversized output: %.80v", output) } } if _, _, err := renderReport("../../escape", map[string]any{"summary": "hello"}); err == nil { t.Fatal("accepted invalid format") } } func reportRunner(t *testing.T, format string) (*runner, int64) { t.Helper() ctx := context.Background() s, err := pipeline.Open(filepath.Join(t.TempDir(), "report.db")) if err != nil { t.Fatal(err) } t.Cleanup(func() { s.Close() }) if _, err := s.Submit(ctx, "report", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } items, _ := s.List(ctx) d, _ := s.Get(ctx, items[0].ID, 1) id, _, err := s.CreateRunTitled(ctx, d, "report-key", "workspace", false, nil, map[string]any{"prompt": "task"}, pipeline.RunOverrides{OutputFormat: format}, summarise.Title{}) if err != nil { t.Fatal(err) } if err := s.BeginStep(ctx, id, 1, "one", nil); err != nil { t.Fatal(err) } if err := s.FinishStep(ctx, id, protocol.RunStep{Sequence: 1, Stage: "one", Status: "completed", Outcome: "success", Output: map[string]any{"markdown": "# Result"}}); err != nil { t.Fatal(err) } return &runner{ctx: ctx, store: s, artifactsRoot: t.TempDir(), notifyModes: map[int64]string{id: "off"}}, id } func TestDeliverableBeforeSuccess(t *testing.T) { for _, format := range []string{"html", "markdown", ""} { t.Run(format, func(t *testing.T) { r, id := reportRunner(t, format) r.finishRunState(id, "report", "workspace", "succeeded", "success", "", 1, 1, "one", stage.Values{"markdown": "# Result"}) d, err := r.store.GetRun(context.Background(), id) if err != nil || d.Status != "succeeded" || d.OutputFormat != format { t.Fatalf("%+v %v", d, err) } if format != "" { if len(d.Steps[0].Artifacts) != 1 { t.Fatalf("missing report inventory: %+v", d.Steps) } file := d.Steps[0].Artifacts[0] if file.SizeBytes <= 0 || !strings.HasPrefix(file.Name, "public/report.") { t.Fatalf("%+v", file) } body, err := os.ReadFile(filepath.Join(r.artifactsRoot, "1", file.Name)) if err != nil || len(body) == 0 { t.Fatalf("missing requested report: %v", err) } } }) } } func TestDeliverableMissingFailsRun(t *testing.T) { r, id := reportRunner(t, "html") r.finishRunState(id, "report", "workspace", "succeeded", "success", "", 1, 1, "one", nil) d, _ := r.store.GetRun(context.Background(), id) if d.Status != "failed" || !strings.Contains(d.Diagnostic, "deliverable contract") { t.Fatalf("missing report succeeded: %+v", d) } } func TestDeliverableRejectsExistingFilesAndSymlinks(t *testing.T) { for _, kind := range []string{"file", "directory", "symlink", "public-symlink", "run-symlink"} { t.Run(kind, func(t *testing.T) { r, id := reportRunner(t, "html") public := filepath.Join(r.artifactsRoot, "1", "public") if err := os.MkdirAll(public, 0755); err != nil { t.Fatal(err) } target := filepath.Join(public, "report.html") outside := filepath.Join(t.TempDir(), "keep") if err := os.WriteFile(outside, []byte("keep"), 0600); err != nil { t.Fatal(err) } var err error switch kind { case "file": err = os.WriteFile(target, []byte("keep"), 0600) case "directory": err = os.Mkdir(target, 0755) case "symlink": err = os.Symlink(outside, target) case "public-symlink": os.Remove(public) err = os.Symlink(filepath.Dir(outside), public) case "run-symlink": os.Remove(public) os.Remove(filepath.Dir(public)) err = os.Symlink(filepath.Dir(outside), filepath.Dir(public)) } if err != nil { t.Fatal(err) } if err := r.finalizeDeliverable(context.Background(), id, 1, map[string]any{"markdown": "new"}); err == nil { t.Fatal("unsafe/existing target accepted") } body, _ := os.ReadFile(outside) if string(body) != "keep" { t.Fatal("outside evidence overwritten") } }) } } func TestOutputFormatRetryInheritanceThroughRuntime(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() s, err := pipeline.Open(filepath.Join(t.TempDir(), "retry-format.db")) if err != nil { t.Fatal(err) } defer s.Close() if _, err := s.Submit(ctx, "report", pipeline.Template([]string{"one"}, true)); err != nil { t.Fatal(err) } items, _ := s.List(ctx) r, err := newRunner(ctx, s) if err != nil { t.Fatal(err) } defer func() { cancel(); r.wg.Wait() }() r.artifactsRoot = t.TempDir() r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{}, fmt.Errorf("fixture failure") } original, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "original-format", Workspace: t.TempDir(), Input: map[string]any{"prompt": "task"}, OutputFormat: "html", NotifyMode: "off"}) if err != nil { t.Fatal(err) } r.wg.Wait() r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) { return stage.Result{Outcome: "success", Output: stage.Values{"markdown": "# Recovered report"}}, nil } retry, err := r.retry(protocol.Message{RunID: original.ID, RequestKey: "retry-format", RetryMode: "restart"}) if err != nil { t.Fatal(err) } r.wg.Wait() retry, err = s.GetRun(ctx, retry.ID) if err != nil || retry.Status != "succeeded" || retry.OutputFormat != "html" { t.Fatalf("contract not inherited: %+v %v", retry, err) } if _, ok := artifactNamed(retry.Steps[0].Artifacts, "public/report.html"); !ok { t.Fatal("retry report missing") } replay, err := r.retry(protocol.Message{RunID: original.ID, RequestKey: "retry-format", RetryMode: "restart"}) if err != nil || replay.ID != retry.ID { t.Fatalf("retry idempotency lost: %+v %v", replay, err) } }