191 lines
6.8 KiB
Go
191 lines
6.8 KiB
Go
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<script>alert(1)</script>"})
|
|
if err != nil || name == "" || len(body) == 0 {
|
|
t.Fatalf("%s: %s %v", format, body, err)
|
|
}
|
|
if format == "html" && (!strings.Contains(string(body), "<h1>Report</h1>") || strings.Contains(string(body), "<script>") || !strings.Contains(string(body), "Content-Security-Policy")) {
|
|
t.Fatalf("unsafe or malformed report: %s", body)
|
|
}
|
|
_, again, _ := renderReport(format, map[string]any{"markdown": "# Report\n\n**Done**\n<script>alert(1)</script>"})
|
|
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)
|
|
}
|
|
}
|