Files
archie/internal/app/agentworker/task_execution_test.go
T
sam 511f5eafc6 test(agentexec): make seeded git repos independent of host signing config
The temp-repo fixtures in agentexec, domain/workflow and agentworker seeded
a repository and committed without disabling gpg signing, so a host with
commit.gpgsign=true and an agent-only SSH signing key failed those tests at
the fixture's own git call ("Couldn't get agent socket?").

Each producer now writes commit.gpgsign=false into the temporary repository's
own config, which also covers commits made inside the seeded repo by a
subprocess (the fake harness). A regression test per package pins the
fixture's hermeticity under a hostile global git config.
2026-10-02 03:06:48 +10:00

970 lines
35 KiB
Go

package agentworker
import (
"context"
"encoding/json"
"log/slog"
"net"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"sync"
"syscall"
"testing"
"time"
"github.com/go-git/go-git/v6"
"github.com/nats-io/nats-server/v2/server"
natssrv "github.com/nats-io/nats-server/v2/test"
natsio "github.com/nats-io/nats.go"
"google.golang.org/grpc"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/domain/workintake"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/forge"
"github.com/samcharles93/archie-core/internal/forgerpc"
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/infrastructure/staterpc"
"github.com/samcharles93/archie-core/internal/infrastructure/workflowsteps"
"github.com/samcharles93/archie-core/internal/installtype"
"github.com/samcharles93/archie-core/internal/taskrun"
"github.com/samcharles93/archie-core/internal/worktree"
"github.com/samcharles93/archie-core/internal/worktreerpc"
)
// testSteps builds the production workflow step vocabulary for tests that are
// not about the vocabulary itself (the composition-level agreement test in
// internal/app/controlplane is).
func testSteps(t *testing.T) *workflow.Manager {
t.Helper()
steps, err := workflowsteps.NewManager()
if err != nil {
t.Fatalf("build workflow step vocabulary: %v", err)
}
return steps
}
// ── regression: archie-core#520 -- worktree ownership must be
// reconciled before push, since the agent commits as root inside the
// container and the daemon reads those same loose objects as its own
// non-root host user ──────────────────────────────────────────────────
type fakePushTrees struct {
pushed bool
pushErr error
}
func (f *fakePushTrees) Push(context.Context) error {
f.pushed = true
return f.pushErr
}
func TestWorktreeOwnerIDParsesEnvValue(t *testing.T) {
cases := []struct {
name string
env string
want int
}{
{"unset", "", -1},
{"zero is a valid uid (root)", "0", 0},
{"typical non-root uid", "1000", 1000},
{"garbage falls back to unset", "not-a-number", -1},
{"negative falls back to unset", "-1", -1},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
if got := worktreeOwnerID(c.env); got != c.want {
t.Errorf("worktreeOwnerID(%q) = %d, want %d", c.env, got, c.want)
}
})
}
}
// TestHybridTreesPushReconcilesOwnershipWhenConfigured chowns to the test
// process's own uid/gid -- a permission no-op that succeeds without root --
// so this proves the walk runs and still reaches the underlying push,
// without needing privilege to chown to an arbitrary owner.
func TestHybridTreesPushReconcilesOwnershipWhenConfigured(t *testing.T) {
dir := t.TempDir()
if err := os.WriteFile(filepath.Join(dir, "file.txt"), []byte("x"), 0o644); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(filepath.Join(dir, "sub"), 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(dir, "sub", "nested.txt"), []byte("y"), 0o644); err != nil {
t.Fatal(err)
}
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: dir,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
// TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink: a repo can
// legitimately track a symlink whose target doesn't exist inside the
// container (e.g. a relative link to something outside the checkout, or to
// a tool the image doesn't ship). Chowning must not follow it -- a
// following chown fails on a dangling target, which would abort a push
// that would otherwise have succeeded, a regression worse than the bug
// being fixed here.
func TestHybridTreesPushReconcilesOwnershipWithDanglingSymlink(t *testing.T) {
dir := t.TempDir()
if err := os.Symlink(filepath.Join(dir, "does-not-exist"), filepath.Join(dir, "broken-link")); err != nil {
t.Fatal(err)
}
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: dir,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
if err := trees.Push(t.Context(), dir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
// TestHybridTreesPushSkipsReconciliationWhenNotConfigured: an unset
// WORKTREE_UID/GID (archie-core's non-container and test callers) must not
// attempt any chown at all -- a nonexistent dir would otherwise fail the
// walk, so this proves the walk is skipped entirely, not just tolerant of
// this one input.
func TestHybridTreesPushSkipsReconciliationWhenNotConfigured(t *testing.T) {
fake := &fakePushTrees{}
trees := &hybridTrees{
push: fake,
localDir: filepath.Join(t.TempDir(), "does-not-exist"),
worktreeUID: -1,
worktreeGID: -1,
}
if err := trees.Push(t.Context(), trees.localDir, "branch"); err != nil {
t.Fatalf("Push: %v", err)
}
if !fake.pushed {
t.Fatal("Push did not reach the underlying remote push")
}
}
func TestHybridTreesCommitReconcilesOwnershipEvenWhenCommitFails(t *testing.T) {
missing := filepath.Join(t.TempDir(), "does-not-exist")
trees := &hybridTrees{
local: &worktree.Manager{},
localDir: missing,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
_, err := trees.CommitAll(t.Context(), missing, "test commit")
if err == nil {
t.Fatal("CommitAll error = nil, want commit and ownership reconciliation failure")
}
if !strings.Contains(err.Error(), "reconcile worktree ownership after commit") {
t.Fatalf("CommitAll error = %q, want ownership reconciliation context", err)
}
}
// TestHybridTreesPushSurfacesOwnershipReconciliationFailure: a configured
// but broken reconciliation (the dir push is asked to fix vanished) must
// fail loudly rather than forward to a push that will only fail later with
// a much more confusing git-internal permission error.
func TestHybridTreesPushSurfacesOwnershipReconciliationFailure(t *testing.T) {
fake := &fakePushTrees{}
missing := filepath.Join(t.TempDir(), "does-not-exist")
trees := &hybridTrees{
push: fake,
localDir: missing,
worktreeUID: os.Getuid(),
worktreeGID: os.Getgid(),
}
err := trees.Push(t.Context(), missing, "branch")
if err == nil {
t.Fatal("expected an error reconciling ownership of a missing directory")
}
if fake.pushed {
t.Fatal("Push must not reach the underlying remote push when reconciliation fails")
}
}
// TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner guards against
// regressing archie-core's tool-result cap and spill dir back to inert
// zero values on the worker path (agentexec-1 / tools-core-11): a
// *LoopRunner built for a task must carry the daemon's configured
// ToolPolicy, not the zero value NewLoopRunner leaves it at.
func TestApplyToolLimitsWiresConfiguredPolicyIntoLoopRunner(t *testing.T) {
runner := agentexec.NewLoopRunner(agentexec.NewRuntime(nil), slog.New(slog.DiscardHandler))
policy := config.ToolPolicy{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
applyToolLimits(runner, policy, []string{"whois"})
want := agentexec.ToolLimits{MaxResultChars: 12345, SpillDir: "/var/tmp/archie-spill"}
if runner.Limits != want {
t.Fatalf("runner.Limits = %+v, want %+v", runner.Limits, want)
}
if len(runner.AllowTools) != 1 || runner.AllowTools[0] != "whois" {
t.Fatalf("runner.AllowTools = %v, want the profile's allowlist", runner.AllowTools)
}
}
// TestApplyToolLimitsIgnoresNonLoopRunner confirms a test-fake runner (which
// is not a *agentexec.LoopRunner) is left untouched rather than panicking.
func TestApplyToolLimitsIgnoresNonLoopRunner(t *testing.T) {
applyToolLimits(panicRunner{t}, config.ToolPolicy{MaxResultChars: 1}, nil)
}
type panicRunner struct{ t *testing.T }
func (r panicRunner) Run(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) {
r.t.Fatal("bootstrap workflow must not invoke an LLM runner")
return agentexec.Result{}, nil
}
type prCapturingForge struct {
prs []struct{ owner, repo, title, head, base, body string }
}
func (f *prCapturingForge) Comment(context.Context, string, string, int, string) (int64, error) {
return 1, nil
}
func (f *prCapturingForge) CloseIssue(context.Context, string, string, int, string) error { return nil }
func (f *prCapturingForge) CreatePR(_ context.Context, owner, repo, title, head, base, body string) (int, error) {
f.prs = append(f.prs, struct{ owner, repo, title, head, base, body string }{owner, repo, title, head, base, body})
return 5, nil
}
func (f *prCapturingForge) SetStateLabel(context.Context, string, string, int, string, []string) {}
func (f *prCapturingForge) AcceptInvitations(context.Context) error { panic("unexpected call") }
func (f *prCapturingForge) AssignedIssues(context.Context, string, string, string) ([]forge.Issue, error) {
panic("unexpected call")
}
func (f *prCapturingForge) IssuesWithLabel(context.Context, string, string, string) ([]forge.Issue, error) {
panic("unexpected call")
}
func (f *prCapturingForge) PRState(context.Context, string, string, int) (string, error) {
panic("unexpected call")
}
func (f *prCapturingForge) CreateIssue(context.Context, string, string, string, string, []string) (int, error) {
panic("unexpected call")
}
func (f *prCapturingForge) React(context.Context, string, string, int, string) error {
panic("unexpected call")
}
func (f *prCapturingForge) VerifyPush(context.Context, string, string) error {
panic("unexpected call")
}
func (f *prCapturingForge) LinkBranch(context.Context, string, string, int, string) error { return nil }
func (f *prCapturingForge) CreateReviewComments(context.Context, string, string, int, string, []workflow.ReviewComment) error {
return nil
}
func (f *prCapturingForge) ReplyToReview(context.Context, string, string, int, int64, string) error {
return nil
}
type remoteManager struct {
manager *worktree.Manager
dir string
branch string
}
func (r *remoteManager) Prepare(ctx context.Context, owner, repo, base string, issue int, title, body, labels string) (string, string, error) {
dir, branch, err := r.manager.Prepare(ctx, owner, repo, base, issue, title, body, labels)
if err == nil {
r.dir = dir
r.branch = branch
}
return dir, branch, err
}
func (r *remoteManager) Push(ctx context.Context) error {
return r.manager.Push(ctx, r.dir, r.branch)
}
func newLocalRemote(t *testing.T, owner, repo string) string {
t.Helper()
host := t.TempDir()
bare := filepath.Join(host, owner, repo+".git")
seed := filepath.Join(t.TempDir(), "seed")
run := func(dir string, args ...string) {
t.Helper()
cmd := exec.CommandContext(t.Context(), "git", args...)
cmd.Dir = dir
cmd.Env = append(os.Environ(), "GIT_TERMINAL_PROMPT=0")
if out, err := cmd.CombinedOutput(); err != nil {
t.Fatalf("git %v: %v\n%s", args, err, out)
}
}
if err := os.MkdirAll(bare, 0o755); err != nil {
t.Fatal(err)
}
run(host, "init", "--bare", "-b", "main", bare)
if err := os.MkdirAll(seed, 0o755); err != nil {
t.Fatal(err)
}
run(seed, "init", "-b", "main")
run(seed, "config", "user.name", "seeder")
run(seed, "config", "user.email", "seed@example.com")
run(seed, "config", "commit.gpgsign", "false")
if err := os.WriteFile(filepath.Join(seed, "README.md"), []byte("seed\n"), 0o644); err != nil {
t.Fatal(err)
}
run(seed, "add", "-A")
run(seed, "commit", "-m", "seed")
run(seed, "push", "file://"+bare, "main")
return host
}
// hostileSigningConfig writes a global git config that makes every commit
// fail unless the fixture disables signing in the repository's own config.
func hostileSigningConfig(t *testing.T) string {
t.Helper()
path := filepath.Join(t.TempDir(), "hostile.gitconfig")
const cfg = "[user]\n\tname = Hostile\n\temail = hostile@example.com\n\tsigningkey = /nonexistent/signing-key\n[gpg]\n\tformat = ssh\n[commit]\n\tgpgsign = true\n"
if err := os.WriteFile(path, []byte(cfg), 0o600); err != nil {
t.Fatal(err)
}
return path
}
// TestNewLocalRemoteIgnoresHostSigningConfig pins the fixture's hermeticity:
// it must not depend on the developer's global git identity or a signing agent.
func TestNewLocalRemoteIgnoresHostSigningConfig(t *testing.T) {
t.Setenv("GIT_CONFIG_GLOBAL", hostileSigningConfig(t))
t.Setenv("GIT_CONFIG_NOSYSTEM", "1")
newLocalRemote(t, "acme", "todo")
}
func startEmbeddedTaskRPCServer(t *testing.T) *server.Server {
t.Helper()
srv := natssrv.RunRandClientPortServer()
t.Cleanup(srv.Shutdown)
if err := srv.EnableJetStream(&server.JetStreamConfig{StoreDir: t.TempDir()}); err != nil {
t.Fatal(err)
}
return srv
}
func connectTaskRPC(t *testing.T, url string) *natsio.Conn {
t.Helper()
connection, err := natsio.Connect(url)
if err != nil {
t.Fatal(err)
}
t.Cleanup(connection.Close)
return connection
}
// startStateStoreGRPC serves the State Store gRPC contract over a loopback
// TCP listener fronting local, returning the dial address. The agent is fully
// on gRPC for its store calls (docs/prds/state-store-contract.md §12 step 4),
// so an agentworker test that drives executeTaskRequest needs a real State
// Store server rather than the deleted NATS storerpc path.
func startStateStoreGRPC(t *testing.T, local *pgstore.TaskDB) string {
t.Helper()
listener, err := (&net.ListenConfig{}).Listen(t.Context(), "tcp", "127.0.0.1:0")
if err != nil {
t.Fatal(err)
}
server := grpc.NewServer()
eda := pgstore.EDA(t, nil)
staterpc.RegisterServer(server, staterpc.Deps{
Tasks: local, Captures: eda, Mappings: eda, Bindings: eda,
BindingDispatcher: eda, BindingTaskCreator: local, WorkflowCalls: local,
Steps: local, Canceller: local,
})
go func() { _ = server.Serve(listener) }()
t.Cleanup(func() { server.Stop(); _ = listener.Close() })
return listener.Addr().String()
}
func TestRunTaskExecutesBootstrapWorkflowEndToEnd(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "widget", 1, "feat: bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatalf("enqueue: %v", err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim: (%v, %v)", task, err)
}
fg := &prCapturingForge{}
manager := &worktree.Manager{WorkDir: t.TempDir(), Token: "unused", BotUser: "archie-bot", BotEmail: "archie-bot@example.com", BaseURL: "file://" + host}
remote := &remoteManager{manager: manager}
hostDir, _, err := remote.Prepare(ctx, "acme", "widget", "main", 1, task.Title, "", "bootstrap")
if err != nil {
t.Fatalf("prepare: %v", err)
}
req := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
Cfg: config.Config{BotUser: "archie-bot", BotEmail: "archie-bot@example.com"}.ForTask(),
}
fakeRunner := runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner { return panicRunner{t} })
response, err := runTask(ctx, req, taskDependencies{forge: fg, store: st, trees: remote, steps: testSteps(t)}, fakeRunner, hostDir, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatalf("runTask: %v", err)
}
if response.Status != workflow.StatusPROpen || len(fg.prs) != 1 {
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(fg.prs), workflow.StatusPROpen)
}
stored, err := st.TaskByIssue(ctx, "acme", "widget", 1)
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
t.Fatalf("stored task = (%+v, %v), want PR-open task #5", stored, err)
}
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
t.Fatalf("expected bootstrap marker file: %v", err)
}
repo, err := git.PlainOpen(hostDir)
if err != nil {
t.Fatal(err)
}
head, err := repo.Head()
if err != nil {
t.Fatal(err)
}
commit, err := repo.CommitObject(head.Hash())
if err != nil {
t.Fatal(err)
}
if commit.Author.Name != "archie-bot" || commit.Author.Email != "archie-bot@example.com" ||
commit.Committer.Name != "archie-bot" || commit.Committer.Email != "archie-bot@example.com" {
t.Fatalf("commit identity = author %q <%s>, committer %q <%s>",
commit.Author.Name, commit.Author.Email, commit.Committer.Name, commit.Committer.Email)
}
// The change the run produced is captured at the push, through the
// container's hybridTrees, and persisted as durable provenance attributed
// to the attempt -- and captured once more by OpenPR, the first moment a
// capture can carry the pull-request number the view links. This is the
// only end-to-end path that matters: every production workflow.Run executes
// here.
timeline, err := st.TaskEvents(ctx, task.ID)
if err != nil {
t.Fatalf("TaskEvents: %v", err)
}
var captured []events.Event
for _, e := range timeline {
if e.Kind == events.KindChangesCaptured {
captured = append(captured, e)
}
}
if len(captured) != 2 {
t.Fatalf("changes_captured events = %d, want the push capture and the one OpenPR takes (%d)", len(captured), stored.PRNumber)
}
for i, e := range captured {
if e.Attempt != task.Attempt || task.Attempt == 0 {
t.Errorf("capture %d attempt = %d, want the task's own attempt %d", i, e.Attempt, task.Attempt)
}
}
if captured[0].Stage != "commit-push" {
t.Errorf("capture stage = %q, want the capturing stage", captured[0].Stage)
}
data, err := json.Marshal(captured[0].Data)
if err != nil {
t.Fatal(err)
}
var payload struct {
CapturedAfter string `json:"captured_after"`
PRNumber int `json:"pr_number"`
Files []struct {
Path string `json:"path"`
Status string `json:"status"`
} `json:"files"`
}
if err := json.Unmarshal(data, &payload); err != nil {
t.Fatalf("decode capture: %v", err)
}
if payload.CapturedAfter != "commit-push" {
t.Errorf("captured_after = %q, want commit-push", payload.CapturedAfter)
}
if payload.PRNumber != 0 {
t.Errorf("the push capture carries pr_number %d, want 0: no PR existed when it was taken", payload.PRNumber)
}
if len(payload.Files) != 1 || payload.Files[0].Path != ".archie/bootstrap.md" || payload.Files[0].Status != "added" {
t.Errorf("captured files = %+v, want the bootstrap marker as an added file", payload.Files)
}
finalData, err := json.Marshal(captured[1].Data)
if err != nil {
t.Fatal(err)
}
var final struct {
CapturedAfter string `json:"captured_after"`
PRNumber int `json:"pr_number"`
}
if err := json.Unmarshal(finalData, &final); err != nil {
t.Fatalf("decode the final capture: %v", err)
}
if final.CapturedAfter != "open-pr" || final.PRNumber != stored.PRNumber || final.PRNumber == 0 {
t.Errorf("final capture = %q pr %d, want open-pr carrying the stored PR number %d, without which the changed-files view has nothing to link",
final.CapturedAfter, final.PRNumber, stored.PRNumber)
}
}
// TestRunTaskRestoresWorktreeOwnershipOnEveryExit pins the half of the
// worktree-ownership contract that archie-core#520 left open. CommitAll and
// Push hand the worktree back to the daemon's own UID on the SUCCESS path;
// every other way a container run can end -- a gate failure that parks the
// task, a stage error, an early return -- used to leave the worktree owned by
// root, because the agent runs as root inside the container. The daemon then
// could not clean or reset those paths on the next attempt (a root-owned
// directory cannot be unlinked from by its non-root owner), so a retry failed
// before it could start no matter what the worktree refresh did.
//
// The run below exits early, which is the point: the restore has to be
// deferred over the whole run rather than attached to the paths that happen to
// commit. It is observed through a supplementary group -- a non-root process
// may move a file it owns into a group it is a member of, so this proves the
// chown ran without needing root.
func TestRunTaskRestoresWorktreeOwnershipOnEveryExit(t *testing.T) {
probeGroup := supplementaryGroup(t)
workDir := t.TempDir()
probe := filepath.Join(workDir, "probe.txt")
if err := os.WriteFile(probe, []byte("x\n"), 0o600); err != nil {
t.Fatal(err)
}
t.Setenv("WORKTREE_UID", strconv.Itoa(os.Getuid()))
t.Setenv("WORKTREE_GID", strconv.Itoa(probeGroup))
// A runner factory that yields nothing fails the run after the trees (and
// the ownership defer) are already in place.
_, err := runTask(t.Context(), taskrun.Request{
Task: &workflow.Task{ID: 77, Branch: "feat/77-probe", Workflow: "implement"},
Repo: config.Repo{Owner: "acme", Name: "widget", Base: "main"},
}, taskDependencies{steps: testSteps(t)}, runnerFactory(func(map[string]agentexec.Provider, *slog.Logger) agentexec.Runner {
return nil
}), workDir, slog.New(slog.DiscardHandler))
if err == nil {
t.Fatal("runTask error = nil, want the missing-runner failure this exit is built around")
}
info, statErr := os.Stat(probe)
if statErr != nil {
t.Fatal(statErr)
}
gid, ok := info.Sys().(*syscall.Stat_t)
if !ok {
t.Fatal("no syscall.Stat_t for the ownership probe")
}
if int(gid.Gid) != probeGroup {
t.Errorf("probe.txt gid = %d, want %d -- a run that never reached CommitAll or Push left the worktree owned by the container's own user", gid.Gid, probeGroup)
}
}
// supplementaryGroup returns a group this process is a member of but that is
// not its primary gid, so a test can observe a chown a non-root process is
// allowed to make.
func supplementaryGroup(t *testing.T) int {
t.Helper()
groups, err := os.Getgroups()
if err != nil {
t.Skipf("os.Getgroups: %v", err)
}
for _, gid := range groups {
if gid != os.Getgid() {
return gid
}
}
t.Skip("process belongs to no supplementary group to chown into")
return 0
}
// TestExecuteTaskRequestUsesInfrastructureRPCDependencies preserves the
// application-to-infrastructure proof: the application asks Transport for its
// forge/store/tree contracts, and those concrete clients cross embedded NATS
// to daemon-side RPC servers before the bootstrap workflow can complete.
func TestExecuteTaskRequestUsesInfrastructureRPCDependencies(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "rpc-widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "rpc-widget", 2, "feat: RPC bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatal(err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
forge := &prCapturingForge{}
daemonTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused-for-file-remotes",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "rpc-widget", "main", 2, task.Title, "", "bootstrap")
if err != nil {
t.Fatal(err)
}
task.Branch = branch
grants := worktreerpc.NewGrants()
grant, revokeGrant, err := grants.Issue(task)
if err != nil {
t.Fatal(err)
}
t.Cleanup(revokeGrant)
srv := startEmbeddedTaskRPCServer(t)
serverConn := connectTaskRPC(t, srv.ClientURL())
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubForge)
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubTrees)
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatal(err)
}
t.Cleanup(transport.Close)
request := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "rpc-widget", Base: "main"},
Cfg: config.Config{}.ForTask(),
WorktreeGrant: grant,
}
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler), testSteps(t))
if err != nil {
t.Fatal(err)
}
if response.Status != workflow.StatusPROpen || len(forge.prs) != 1 {
t.Fatalf("response status/PRs = (%q, %d), want (%q, 1)", response.Status, len(forge.prs), workflow.StatusPROpen)
}
// archie-core-1786751948782-3-837a8fd0 point 4: every response reports
// what this worker actually is, since it's the only channel the daemon
// has to learn what's really running (see daemon.AgentStatus).
if response.AgentVersion != Version() {
t.Errorf("response.AgentVersion = %q, want Version() = %q", response.AgentVersion, Version())
}
if response.AgentInstallType != installtype.Type() {
t.Errorf("response.AgentInstallType = %q, want installtype.Type() = %q", response.AgentInstallType, installtype.Type())
}
stored, err := st.TaskByIssue(ctx, "acme", "rpc-widget", 2)
if err != nil || stored == nil || stored.Status != workflow.StatusPROpen || stored.PRNumber != 5 {
t.Fatalf("stored task = (%+v, %v), want RPC-persisted PR-open task #5", stored, err)
}
if _, err := os.Stat(filepath.Join(hostDir, ".archie", "bootstrap.md")); err != nil {
t.Fatalf("expected bootstrap marker file: %v", err)
}
}
// TestExecuteTaskRequestForwardsWorkflowEventsOverNATS is the regression test
// for the "No events yet" dashboard bug (archie-core-518): a workflow run
// through the NATS/container path publishes its stage/outcome events to an
// in-process *events.Bus nothing on the daemon side could see, because
// runTask never wired TaskContext.Bus. This proves the fix end to end -- a
// bystander subscribed directly to SubjectForEvents(task.ID) on the same
// embedded NATS server executeTaskRequest uses receives real events the
// bootstrap workflow emits, exactly as the daemon's own subscriber would.
func TestExecuteTaskRequestForwardsWorkflowEventsOverNATS(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "events-widget")
st := pgstore.Open(t)
if _, err := st.EnqueueIssue(ctx, "acme", "events-widget", 3, "feat: events bootstrap test", "", "bootstrap", ""); err != nil {
t.Fatal(err)
}
task, err := st.ClaimNext(ctx)
if err != nil || task == nil {
t.Fatalf("claim = (%+v, %v)", task, err)
}
forge := &prCapturingForge{}
daemonTrees := &worktree.Manager{
WorkDir: t.TempDir(),
Token: "unused-for-file-remotes",
BotUser: "archie-bot",
BotEmail: "archie-bot@example.com",
BaseURL: "file://" + host,
}
hostDir, branch, err := daemonTrees.Prepare(ctx, "acme", "events-widget", "main", 3, task.Title, "", "bootstrap")
if err != nil {
t.Fatal(err)
}
task.Branch = branch
grants := worktreerpc.NewGrants()
grant, revokeGrant, err := grants.Issue(task)
if err != nil {
t.Fatal(err)
}
t.Cleanup(revokeGrant)
srv := startEmbeddedTaskRPCServer(t)
serverConn := connectTaskRPC(t, srv.ClientURL())
unsubForge, err := (&forgerpc.Server{Forge: forge, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubForge)
unsubTrees, err := (&worktreerpc.Server{Trees: daemonTrees, Grants: grants, Log: slog.New(slog.DiscardHandler)}).Register(serverConn)
if err != nil {
t.Fatal(err)
}
t.Cleanup(unsubTrees)
// Stand in for the daemon's own SubjectEventsWildcard subscriber: bind
// to the exact per-task subject before the workflow runs, so nothing
// published during the run can be missed.
var (
mu sync.Mutex
received []events.Event
)
bystander := connectTaskRPC(t, srv.ClientURL())
eventSub, err := bystander.Subscribe(agentexec.SubjectForEvents(task.ID), func(msg *natsio.Msg) {
var e events.Event
if err := json.Unmarshal(msg.Data, &e); err != nil {
t.Errorf("undecodable event message: %v", err)
return
}
mu.Lock()
received = append(received, e)
mu.Unlock()
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = eventSub.Unsubscribe() })
if err := bystander.Flush(); err != nil {
t.Fatal(err)
}
transport, err := agentnats.Connect(ctx, agentnats.Config{URL: srv.ClientURL(), StateStoreURL: startStateStoreGRPC(t, st)}, slog.New(slog.DiscardHandler))
if err != nil {
t.Fatal(err)
}
t.Cleanup(transport.Close)
request := taskrun.Request{
Task: task,
Repo: config.Repo{Owner: "acme", Name: "events-widget", Base: "main"},
Cfg: config.Config{}.ForTask(),
WorktreeGrant: grant,
}
response, err := executeTaskRequest(ctx, request, transport, hostDir, slog.New(slog.DiscardHandler), testSteps(t))
if err != nil {
t.Fatal(err)
}
if response.Status != workflow.StatusPROpen {
t.Fatalf("response status = %q, want %q", response.Status, workflow.StatusPROpen)
}
deadline := time.After(2 * time.Second)
for {
mu.Lock()
sawOutcome := false
for _, e := range received {
if e.Kind == events.KindOutcome {
sawOutcome = true
break
}
}
mu.Unlock()
if sawOutcome {
break
}
select {
case <-deadline:
t.Fatal("no \"outcome\" event arrived on SubjectForEvents(task.ID) within 2s")
case <-time.After(10 * time.Millisecond):
}
}
mu.Lock()
defer mu.Unlock()
sawOutcome := false
for _, e := range received {
if e.TaskID != task.ID {
t.Errorf("event %+v carries TaskID %d, want %d", e, e.TaskID, task.ID)
}
if e.Kind == events.KindOutcome {
sawOutcome = true
}
}
if !sawOutcome {
t.Errorf("received %d events %+v, want at least one %q", len(received), received, events.KindOutcome)
}
}
// TestRouteTaskUsesRequestKindOverride is the regression for
// workflow-engine-1: a kind -> workflow override loaded by the daemon is
// carried in the taskrun request and applied by the worker process, so
// workflow.Route honours it instead of silently falling back to the
// built-in default (bug -> tdd).
func TestRouteTaskUsesRequestKindOverride(t *testing.T) {
t.Cleanup(func() {
workflow.SetKindWorkflows(nil)
workflow.SetLabelWorkflows(nil)
})
registry := workflow.Registry{
"tdd": workflow.Workflow{Name: "tdd"},
"bootstrap": workflow.Workflow{Name: "bootstrap"},
"implement": workflow.Workflow{Name: "implement"},
}
req := taskrun.Request{
Task: &workflow.Task{Labels: "bug"},
KindWorkflows: workflow.KindWorkflows{workintake.KindBug: "bootstrap"},
}
wf := routeTask(req, registry)
if wf.Name != "bootstrap" {
t.Fatalf("routeTask() = %q, want %q (request kind override not applied)", wf.Name, "bootstrap")
}
}
// TestRouteTaskUsesRequestLabelOverride is the label counterpart: an
// arbitrary-label binding carried in the request also reaches the worker's
// routing decision.
func TestRouteTaskUsesRequestLabelOverride(t *testing.T) {
t.Cleanup(func() {
workflow.SetKindWorkflows(nil)
workflow.SetLabelWorkflows(nil)
})
registry := workflow.Registry{
"implement": workflow.Workflow{Name: "implement"},
"security-review": workflow.Workflow{Name: "security-review"},
}
req := taskrun.Request{
Task: &workflow.Task{Labels: "security"},
LabelWorkflows: workflow.LabelWorkflows{"security": "security-review"},
}
wf := routeTask(req, registry)
if wf.Name != "security-review" {
t.Fatalf("routeTask() = %q, want %q (request label override not applied)", wf.Name, "security-review")
}
}
// changeStatsReader mirrors the unexported optional interface package workflow
// type-asserts on TaskContext.Trees to capture what an attempt changed. It is
// restated here because an unexported interface cannot be named from this
// package; the assertion below is therefore the only way this side can pin
// that the in-container Trees is capable at all.
type changeStatsReader interface {
ChangedFileStats(ctx context.Context, dir, base string) (task.ChangeStats, error)
}
// TestHybridTreesCanReportWhatChanged is the in-container half of the change
// capture. Every production workflow.Run executes in archie-agent against a
// hybridTrees, so a Trees without this capability would make the capture a
// silent no-op in exactly the deployment that produces all the real data --
// the daemon-side manager being capable would prove nothing.
func TestHybridTreesCanReportWhatChanged(t *testing.T) {
var trees any = &hybridTrees{local: &worktree.Manager{}}
if _, ok := trees.(changeStatsReader); !ok {
t.Fatal("hybridTrees cannot report a diffstat; every capture inside a container would silently no-op")
}
}
// TestHybridTreesForwardsChangedFileStatsToItsLocalManager drives the
// capability against a real worktree, so satisfaction of the interface is not
// mistaken for a working forwarder.
func TestHybridTreesForwardsChangedFileStatsToItsLocalManager(t *testing.T) {
if _, err := exec.LookPath("git"); err != nil {
t.Skip("git not installed")
}
ctx := t.Context()
host := newLocalRemote(t, "acme", "diffstat")
manager := &worktree.Manager{
WorkDir: t.TempDir(), Token: "unused",
BotUser: "archie-bot", BotEmail: "archie-bot@example.com", BaseURL: "file://" + host,
}
dir, branch, err := manager.Prepare(ctx, "acme", "diffstat", "main", 4, "feat: widget", "", "")
if err != nil {
t.Fatalf("prepare: %v", err)
}
if err := os.WriteFile(filepath.Join(dir, "widget.txt"), []byte("one\ntwo\n"), 0o644); err != nil {
t.Fatal(err)
}
if _, err := manager.CommitAll(ctx, dir, "feat: widget"); err != nil {
t.Fatalf("commit: %v", err)
}
trees := &hybridTrees{local: manager, localDir: dir, branch: branch}
stats, err := trees.ChangedFileStats(ctx, dir, "main")
if err != nil {
t.Fatalf("ChangedFileStats: %v", err)
}
if len(stats.Files) != 1 || stats.Files[0].Path != "widget.txt" {
t.Fatalf("files = %+v, want the one committed file", stats.Files)
}
if stats.Totals != (task.ChangeTotals{Files: 1, Additions: 2}) {
t.Errorf("totals = %+v, want the file's two added lines", stats.Totals)
}
if stats.HeadSHA == "" || stats.BaseSHA == "" {
t.Errorf("SHAs = (%q, %q), want both resolved", stats.BaseSHA, stats.HeadSHA)
}
}
// uncommittedChangeReporter mirrors the unexported optional interface package
// workflow type-asserts on TaskContext.Trees to tell a change that is not
// committed yet from a branch with no change. It is restated here for the same
// reason changeStatsReader is: an unexported interface cannot be named from this
// package, so this assertion is the only way this side can pin that the
// in-container Trees can answer at all.
type uncommittedChangeReporter interface {
HasUncommittedChanges(ctx context.Context, dir string) (bool, error)
}
// TestHybridTreesCanReportUncommittedWork is the in-container half of the
// diff-rules placement guard. Every production workflow.Run executes in
// archie-agent against a hybridTrees, and a workflow whose only Trees cannot
// answer would fail the guard for the wrong reason -- or, worse, look capable
// while forwarding nothing.
func TestHybridTreesCanReportUncommittedWork(t *testing.T) {
var trees any = &hybridTrees{local: &worktree.Manager{}}
if _, ok := trees.(uncommittedChangeReporter); !ok {
t.Fatal("hybridTrees cannot report uncommitted work, so the in-container diff-rules guard would refuse every run")
}
}