317 lines
9.5 KiB
Go
317 lines
9.5 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"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"
|
|
)
|
|
|
|
func TestRetainedStageDiffsAcrossVisitsAndFailures(t *testing.T) {
|
|
for _, ending := range []string{"success", "error", "panic", "cancel", "cleanup"} {
|
|
t.Run(ending, func(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
db := filepath.Join(t.TempDir(), "runs.db")
|
|
store, err := pipeline.Open(db)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
source := pipeline.Template([]string{"one", "two"}, true)
|
|
if _, err = store.Submit(ctx, "changes", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := store.List(ctx)
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dir := t.TempDir()
|
|
file := filepath.Join(dir, "result.txt")
|
|
if err = os.WriteFile(file, []byte("preexisting edit\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.execute = func(_ context.Context, def stage.Definition, _ stage.Values) (stage.Result, error) {
|
|
text := "stage " + def.Key + "\n"
|
|
if err := os.WriteFile(file, []byte(text), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if def.Key == "two" {
|
|
switch ending {
|
|
case "error":
|
|
return stage.Result{}, errors.New("failed after edit")
|
|
case "panic":
|
|
panic("fixture")
|
|
case "cancel":
|
|
cancel()
|
|
return stage.Result{}, context.Canceled
|
|
case "cleanup":
|
|
return stage.Result{}, stage.ErrStageCleanup
|
|
}
|
|
}
|
|
return stage.Result{Outcome: "success", Output: stage.Values{"summary": text}}, nil
|
|
}
|
|
run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "diff", Workspace: dir, Input: map[string]any{"prompt": "task"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
if err = store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
store, err = pipeline.Open(db)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
detail, err := store.GetRun(context.Background(), run.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(detail.Steps) != 2 {
|
|
t.Fatal(detail)
|
|
}
|
|
for i, step := range detail.Steps {
|
|
c := step.FileChanges
|
|
if c == nil || len(c.Files) != 1 {
|
|
t.Fatal("diff not retained", step)
|
|
}
|
|
expected := "preexisting edit"
|
|
if i == 1 {
|
|
expected = "stage one"
|
|
}
|
|
if !strings.Contains(c.Files[0].Patch, "-"+expected) || !strings.Contains(c.Files[0].Patch, "+stage "+step.Stage) {
|
|
t.Fatal("wrong stage baseline", c)
|
|
}
|
|
if ending == "cleanup" && i == 1 && c.Status != "partial" {
|
|
t.Fatal("live agent capture not flagged", c)
|
|
}
|
|
}
|
|
want := "failed"
|
|
if ending == "success" {
|
|
want = "succeeded"
|
|
}
|
|
if ending == "cancel" {
|
|
want = "canceled"
|
|
}
|
|
if detail.Status != want {
|
|
t.Fatal("diff changed verdict", detail.Status, want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRepeatedStageVisitsRetainIndependentDiffs(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
s, err := pipeline.Open(filepath.Join(t.TempDir(), "loops.db"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer s.Close()
|
|
source := strings.Replace(pipeline.Template([]string{"one"}, true), "success -> #success", "success -> one\ndone -> #success", 1)
|
|
if _, err = s.Submit(ctx, "loop", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, _ := s.List(ctx)
|
|
r, err := newRunner(ctx, s)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
dir := t.TempDir()
|
|
path := filepath.Join(dir, "file")
|
|
os.WriteFile(path, []byte("visit 0\n"), 0600)
|
|
visit := 0
|
|
r.execute = func(context.Context, stage.Definition, stage.Values) (stage.Result, error) {
|
|
visit++
|
|
if err := os.WriteFile(path, []byte(fmt.Sprintf("visit %d\n", visit)), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
outcome := "success"
|
|
if visit == 3 {
|
|
outcome = "done"
|
|
}
|
|
return stage.Result{Outcome: outcome}, nil
|
|
}
|
|
run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "loop", Workspace: dir, Input: map[string]any{"prompt": "task"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
detail, err := s.GetRun(ctx, run.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(detail.Steps) != 3 || detail.Status != "succeeded" {
|
|
t.Fatal(detail)
|
|
}
|
|
for i, step := range detail.Steps {
|
|
if step.FileChanges == nil || len(step.FileChanges.Files) != 1 {
|
|
t.Fatal(step)
|
|
}
|
|
patch := step.FileChanges.Files[0].Patch
|
|
if !strings.Contains(patch, fmt.Sprintf("-visit %d", i)) || !strings.Contains(patch, fmt.Sprintf("+visit %d", i+1)) {
|
|
t.Fatal("wrong visit evidence", patch)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRetainedStageDiffsSurviveCommittedMergeAndNoopVisit(t *testing.T) {
|
|
ctx := context.Background()
|
|
db := filepath.Join(t.TempDir(), "committed-diffs.db")
|
|
store, err := pipeline.Open(db)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
source := pipeline.Template([]string{"commit", "merge", "noop"}, true)
|
|
if _, err := store.Submit(ctx, "committed-diffs", source); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
items, err := store.List(ctx)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
workspace := t.TempDir()
|
|
runGit(t, workspace, "init", "-q")
|
|
runGit(t, workspace, "config", "user.email", "test@example.invalid")
|
|
runGit(t, workspace, "config", "user.name", "test")
|
|
path := filepath.Join(workspace, "source.txt")
|
|
if err := os.WriteFile(path, []byte("base\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runGit(t, workspace, "add", "source.txt")
|
|
runGit(t, workspace, "commit", "-qm", "base")
|
|
branch := runGitOutput(t, workspace, "branch", "--show-current")
|
|
|
|
r, err := newRunner(ctx, store)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
git := func(args ...string) error {
|
|
cmd := exec.Command("git", append([]string{"-C", workspace}, args...)...)
|
|
if output, err := cmd.CombinedOutput(); err != nil {
|
|
return fmt.Errorf("git %v: %w: %s", args, err, output)
|
|
}
|
|
return nil
|
|
}
|
|
gitOutput := func(args ...string) (string, error) {
|
|
cmd := exec.Command("git", append([]string{"-C", workspace}, args...)...)
|
|
output, err := cmd.Output()
|
|
if err != nil {
|
|
return "", fmt.Errorf("git %v: %w", args, err)
|
|
}
|
|
return strings.TrimSpace(string(output)), nil
|
|
}
|
|
r.execute = func(_ context.Context, def stage.Definition, _ stage.Values) (stage.Result, error) {
|
|
switch def.Key {
|
|
case "commit":
|
|
if err := os.WriteFile(path, []byte("committed change\n"), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("add", "source.txt"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("commit", "-qm", "stage commit"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
case "merge":
|
|
if err := git("checkout", "-qb", "conflict-side"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := os.WriteFile(path, []byte("side change\n"), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("add", "source.txt"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("commit", "-qm", "side"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("checkout", "-q", branch); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := os.WriteFile(path, []byte("main change\n"), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("add", "source.txt"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("commit", "-qm", "main"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("merge", "--no-ff", "conflict-side", "-m", "merge"); err == nil {
|
|
return stage.Result{}, errors.New("expected merge conflict")
|
|
}
|
|
conflicted, err := gitOutput("diff", "--name-only", "--diff-filter=U")
|
|
if err != nil || conflicted != "source.txt" {
|
|
return stage.Result{}, fmt.Errorf("merge did not leave the expected conflict: %q, %v", conflicted, err)
|
|
}
|
|
if err := os.WriteFile(path, []byte("resolved merge\n"), 0600); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("add", "source.txt"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
if err := git("commit", "-qm", "resolve merge"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
case "noop":
|
|
if err := git("commit", "--allow-empty", "-qm", "no content change"); err != nil {
|
|
return stage.Result{}, err
|
|
}
|
|
}
|
|
return stage.Result{Outcome: "success"}, nil
|
|
}
|
|
|
|
run, err := r.start(protocol.Message{PipelineID: items[0].ID, Version: 1, RequestKey: "committed-diffs", Workspace: workspace, Input: map[string]any{"prompt": "task"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r.wg.Wait()
|
|
if err := store.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
store, err = pipeline.Open(db)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer store.Close()
|
|
|
|
detail, err := store.GetRun(ctx, run.ID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if detail.Status != "succeeded" || len(detail.Steps) != 3 {
|
|
t.Fatal(detail)
|
|
}
|
|
for _, assertion := range []struct {
|
|
step int
|
|
old string
|
|
new string
|
|
}{
|
|
{step: 0, old: "base", new: "committed change"},
|
|
{step: 1, old: "committed change", new: "resolved merge"},
|
|
} {
|
|
changes := detail.Steps[assertion.step].FileChanges
|
|
if changes == nil || len(changes.Files) != 1 || !strings.Contains(changes.Files[0].Patch, "-"+assertion.old) || !strings.Contains(changes.Files[0].Patch, "+"+assertion.new) {
|
|
t.Fatalf("committed stage patch was not retained after reopen: %+v", changes)
|
|
}
|
|
}
|
|
if changes := detail.Steps[2].FileChanges; changes == nil || len(changes.Files) != 0 {
|
|
t.Fatalf("commit-only stage changed source evidence: %+v", changes)
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err != nil || string(data) != "resolved merge\n" {
|
|
t.Fatalf("merge resolution was not preserved: %q, %v", data, err)
|
|
}
|
|
}
|