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 ending == "cleanup" { want = "running" if !detail.CleanupUnconfirmed || detail.FinishedAt != "" { t.Fatal("unconfirmed cleanup reported as settled", detail) } } 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) } }