Files
archie/internal/daemon/terminal_cleanup_test.go
T
sam dbaa7284a3 feat(taskactions): archive reaps the task's worktree; cleanup test models a completed run
A worktree terminal cleanup keeps (uncaptured or unreadable work) now has a
reap path: archiving calls Daemon.RemoveWorktree for the owning identity's
trees, and the keep logs name archive as the way out. The no-change cleanup
test reports completed through one direct transition instead of reaching
merged via a faked pr_open hop.
2026-09-27 13:38:12 +10:00

425 lines
13 KiB
Go

package daemon
import (
"context"
"encoding/json"
"errors"
"io/fs"
"log/slog"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
"github.com/go-git/go-git/v6"
gitconfig "github.com/go-git/go-git/v6/config"
"github.com/go-git/go-git/v6/plumbing"
"github.com/go-git/go-git/v6/plumbing/object"
dockercontainer "github.com/moby/moby/api/types/container"
"github.com/moby/moby/client"
natsio "github.com/nats-io/nats.go"
"github.com/samcharles93/archie-core/internal/config"
archiecontainer "github.com/samcharles93/archie-core/internal/container"
"github.com/samcharles93/archie-core/internal/domain/workflow"
agentnats "github.com/samcharles93/archie-core/internal/infrastructure/agenttransport/nats"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
"github.com/samcharles93/archie-core/internal/storage"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/taskstate/taskstatetest"
"github.com/samcharles93/archie-core/internal/worktree"
)
type noopStorage struct{}
func (s *noopStorage) Setup(context.Context, storage.TaskRef) ([]storage.Mount, error) {
return nil, nil
}
func (s *noopStorage) Teardown(context.Context, storage.TaskRef) error {
return nil
}
func (s *noopStorage) CleanupExpired(context.Context, time.Duration) (int, error) {
return 0, nil
}
func newLocalRemote(t *testing.T, owner, repo string) string {
t.Helper()
host := t.TempDir()
bare := filepath.Join(host, owner, repo+".git")
mainRef := plumbing.NewBranchReferenceName("main")
if _, err := git.PlainInit(bare, true, git.WithDefaultBranch(mainRef)); err != nil {
t.Fatalf("init bare remote: %v", err)
}
seed := filepath.Join(t.TempDir(), "seed")
sr, err := git.PlainInit(seed, false, git.WithDefaultBranch(mainRef))
if err != nil {
t.Fatalf("init seed repo: %v", err)
}
cfg, err := sr.Config()
if err != nil {
t.Fatalf("read seed config: %v", err)
}
cfg.Raw.Section("commit").SetOption("gpgsign", "false")
if err := sr.SetConfig(cfg); err != nil {
t.Fatalf("write seed config: %v", err)
}
if err := os.WriteFile(filepath.Join(seed, "README.md"), []byte("seed\n"), 0o600); err != nil {
t.Fatal(err)
}
wt, err := sr.Worktree()
if err != nil {
t.Fatal(err)
}
if _, err := wt.Add("README.md"); err != nil {
t.Fatal(err)
}
sig := &object.Signature{Name: "test", Email: "test@test", When: time.Now()}
h, err := wt.Commit("seed", &git.CommitOptions{Author: sig, Committer: sig})
if err != nil {
t.Fatal(err)
}
if _, err := sr.CreateRemote(&gitconfig.RemoteConfig{
Name: git.DefaultRemoteName,
URLs: []string{bare},
}); err != nil {
t.Fatalf("create remote: %v", err)
}
if err := sr.PushContext(t.Context(), &git.PushOptions{
RemoteName: git.DefaultRemoteName,
RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec(mainRef + ":" + mainRef)},
}); err != nil {
t.Fatalf("push seed to bare remote: %v", err)
}
_ = h
return host
}
// newTestTrees returns a worktree manager whose clones come from the local
// bare remote at host, so a fixture can prepare the clone the daemon would.
func newTestTrees(t *testing.T, host string) *worktree.Manager {
t.Helper()
return &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
}
func TestCleanupTerminalTaskWorktreeLifecycle(t *testing.T) {
host := newLocalRemote(t, "acme", "widget")
tests := []struct {
name string
taskIdentity string
setupStatus string
prNumber int
uncommitted bool
wantTreeExists bool
}{
{
name: "root no-change merged task cleans worktree",
taskIdentity: "",
setupStatus: workflow.StatusMerged,
prNumber: 0,
wantTreeExists: false,
},
{
name: "multi-identity no-change merged task cleans identity worktree",
taskIdentity: "winter",
setupStatus: workflow.StatusMerged,
prNumber: 0,
wantTreeExists: false,
},
{
name: "root no-change completed task cleans worktree",
taskIdentity: "",
setupStatus: workflow.StatusCompleted,
prNumber: 0,
wantTreeExists: false,
},
{
name: "multi-identity no-change completed task cleans identity worktree",
taskIdentity: "winter",
setupStatus: workflow.StatusCompleted,
prNumber: 0,
wantTreeExists: false,
},
{
// agent.run ends a task completed with its deliverable still
// uncommitted in the clone. Deleting that worktree deletes the
// work: nothing else anywhere holds those edits.
name: "completed task keeps a worktree that holds uncommitted work",
taskIdentity: "",
setupStatus: workflow.StatusCompleted,
prNumber: 0,
uncommitted: true,
wantTreeExists: true,
},
{
name: "merged task keeps a worktree that holds uncommitted work",
taskIdentity: "",
setupStatus: workflow.StatusMerged,
prNumber: 0,
uncommitted: true,
wantTreeExists: true,
},
{
name: "parked task preserves worktree for post-mortem",
taskIdentity: "",
setupStatus: workflow.StatusParked,
prNumber: 0,
wantTreeExists: true,
},
{
name: "open PR task preserves worktree for PR reconciliation",
taskIdentity: "",
setupStatus: workflow.StatusPROpen,
prNumber: 42,
wantTreeExists: true,
},
{
name: "waiting human task preserves worktree",
taskIdentity: "",
setupStatus: workflow.StatusWaitingHuman,
prNumber: 0,
wantTreeExists: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
ctx := context.Background()
st := pgstore.Open(t)
t.Cleanup(func() { _ = st.Close() })
rootTrees := newTestTrees(t, host)
winterTrees := newTestTrees(t, host)
log := slog.New(slog.DiscardHandler)
d := &Daemon{
Store: st,
Trees: rootTrees,
Identities: []*IdentityRunner{
{
Name: "winter",
Trees: winterTrees,
Forge: &testForge{},
Repos: []config.Repo{{Owner: "acme", Name: "widget"}},
Cfg: config.IdentityConfig{Name: "winter"},
Log: log,
},
},
Log: log,
}
issueNum := 101
if _, err := st.EnqueueIssue(ctx, "acme", "widget", issueNum, "test task", "body", "bug", tt.taskIdentity); err != nil {
t.Fatalf("EnqueueIssue: %v", err)
}
claimed, err := st.ClaimNext(ctx)
if err != nil || claimed == nil {
t.Fatalf("ClaimNext: (%v, %v)", claimed, err)
}
// Seeded along the table's legal edges: a merged task reached
// `merged` through an open pull request, never from running.
taskstatetest.Seed(ctx, t, st, claimed.ID, claimed.Status, tt.setupStatus, "status update")
if tt.prNumber > 0 {
claimed.PRNumber = tt.prNumber
if err := st.Update(ctx, claimed); err != nil {
t.Fatalf("Update PRNumber: %v", err)
}
}
targetTrees := d.treesFor(claimed)
workDir := targetTrees.Dir(claimed.Owner, claimed.Repo, claimed.IssueNumber)
// A prepared clone, the only shape the daemon ever cleans up.
if _, _, err := targetTrees.Prepare(ctx, claimed.Owner, claimed.Repo, "main",
claimed.IssueNumber, claimed.Title, claimed.Body, claimed.Labels); err != nil {
t.Fatalf("prepare worktree: %v", err)
}
if tt.uncommitted {
if err := os.WriteFile(filepath.Join(workDir, "deliverable.md"), []byte("uncommitted work\n"), 0o600); err != nil {
t.Fatalf("write uncommitted work: %v", err)
}
}
d.cleanupTerminalTaskWorktree(ctx, claimed, targetTrees)
_, statErr := os.Stat(workDir)
treeExists := statErr == nil
if treeExists != tt.wantTreeExists {
t.Errorf("worktree exists = %v, want %v (path: %s)", treeExists, tt.wantTreeExists, workDir)
}
})
}
}
func TestProcessCleansWorktreeOnTerminalNoChange(t *testing.T) {
tests := []struct {
name string
workerStatus string
taskIdentity string
wantTreeExists bool
}{
{
name: "process removes worktree when worker completes without a PR",
workerStatus: workflow.StatusCompleted,
taskIdentity: "",
wantTreeExists: false,
},
{
name: "process removes identity worktree when worker completes without a PR",
workerStatus: workflow.StatusCompleted,
taskIdentity: "winter",
wantTreeExists: false,
},
{
name: "process keeps worktree when worker parks task",
workerStatus: workflow.StatusParked,
taskIdentity: "",
wantTreeExists: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
host := newLocalRemote(t, "acme", "widget")
d, s, busClient := daemonWithNATS(t)
ctx := context.Background()
rootTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
winterTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused",
BotUser: "winter-bot",
BotEmail: "winter-bot@example.com",
BaseURL: "file://" + host,
}
d.Trees = rootTrees
repo := config.Repo{Owner: "acme", Name: "widget", Base: "main"}
d.Cfg.Set(config.Config{
Repos: []config.Repo{repo},
})
d.Identities = []*IdentityRunner{
{
Name: "winter",
Trees: winterTrees,
Forge: &testForge{},
Repos: []config.Repo{repo},
Cfg: config.IdentityConfig{Name: "winter"},
Log: d.Log,
},
}
// Mock Docker API server for ContainerPool
dockerAPI := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch {
case strings.HasSuffix(r.URL.Path, "/containers/create"):
writeContainerDockerJSON(t, w, dockercontainer.CreateResponse{ID: "test-container-id"})
case strings.Contains(r.URL.Path, "/containers/test-container-id"):
w.WriteHeader(http.StatusNoContent)
case strings.HasSuffix(r.URL.Path, "/containers/json"):
writeContainerDockerJSON(t, w, []any{})
default:
http.Error(w, "unexpected Docker API path "+r.URL.Path, http.StatusNotFound)
}
}))
t.Cleanup(dockerAPI.Close)
dockerClient, err := client.New(client.WithHost(dockerAPI.URL), client.WithAPIVersion("1.55"))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = dockerClient.Close() })
pool, err := archiecontainer.NewPool(ctx, archiecontainer.Config{
Image: "archie-agent:test",
DockerClient: dockerClient,
}, d.Log)
if err != nil {
t.Fatal(err)
}
d.ContainerPool = pool
d.Storage = &noopStorage{}
if _, err := s.EnqueueIssue(ctx, "acme", "widget", 77, "no-op issue", "body", "bug", tt.taskIdentity); err != nil {
t.Fatal(err)
}
task, err := s.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("ClaimNext: (%v, %v)", task, err)
}
targetTrees := d.treesFor(task)
workDir := targetTrees.Dir(task.Owner, task.Repo, task.IssueNumber)
sub, err := mustCoreConn(t, busClient).Subscribe(agentnats.SubjectForTask(task.ID), func(msg *natsio.Msg) {
// Transition task in store as archie-agent would do over the gRPC State Store
_ = s.Transition(ctx, task.ID, workflow.StatusRunning, tt.workerStatus, "worker completion")
resp, _ := json.Marshal(taskrun.Response{
Status: tt.workerStatus,
})
_ = msg.Respond(resp)
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = sub.Unsubscribe() })
d.process(ctx, task)
_, statErr := os.Stat(workDir)
treeExists := statErr == nil
if treeExists != tt.wantTreeExists {
t.Errorf("worktree exists = %v, want %v (path: %s)", treeExists, tt.wantTreeExists, workDir)
}
})
}
}
// TestRemoveWorktreeReapsTheOwningIdentitysClone is the operator's reap path
// for a worktree terminal cleanup kept: archiving removes the clone under the
// trees of the identity that owns the task, and only that clone.
func TestRemoveWorktreeReapsTheOwningIdentitysClone(t *testing.T) {
root := &worktree.Manager{WorkDir: t.TempDir()}
winter := &worktree.Manager{WorkDir: t.TempDir()}
d := &Daemon{Trees: root, Identities: []*IdentityRunner{{Name: "winter", Trees: winter}}}
for _, m := range []*worktree.Manager{root, winter} {
if err := os.MkdirAll(m.Dir("acme", "widget", 7), 0o755); err != nil {
t.Fatal(err)
}
}
if err := d.RemoveWorktree("acme", "widget", "winter", 7); err != nil {
t.Fatalf("RemoveWorktree: %v", err)
}
if _, err := os.Stat(winter.Dir("acme", "widget", 7)); !errors.Is(err, fs.ErrNotExist) {
t.Errorf("identity worktree still on disk: %v", err)
}
if _, err := os.Stat(root.Dir("acme", "widget", 7)); err != nil {
t.Errorf("root worktree removed: %v", err)
}
}