relay-flow 0.0.1 → 0.2.0-alpha

package/internal/run/run_manager_test.go

@@ -0,0 +1,266 @@
+package run_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/repo"
+	"github.com/rajpopat27/relay-flow/internal/run"
+	"github.com/rajpopat27/relay-flow/internal/task"
+	"github.com/rajpopat27/relay-flow/internal/workflow"
+)
+
+// 3.12: claim ordering per specs/repo-workflow-routing "Claim is persisted
+// before run creation" and docs RunManager.EnsureRun ordering.
+
+// eventLog is a shared ordered log across the fake task system and fake
+// executor, proving claim-before-run-creation ordering.
+type eventLog struct {
+	mu     chan struct{}
+	events []string
+}
+
+func newEventLog() *eventLog { return &eventLog{mu: make(chan struct{}, 1)} }
+
+func (l *eventLog) add(e string) {
+	l.mu <- struct{}{}
+	l.events = append(l.events, e)
+	<-l.mu
+}
+
+func (l *eventLog) all() []string {
+	l.mu <- struct{}{}
+	defer func() { <-l.mu }()
+	return append([]string{}, l.events...)
+}
+
+// recordingSystem records Claim/HasComment calls into the shared log.
+type recordingSystem struct {
+	task.System
+	log         *eventLog
+	claimErr    error
+	hasCancel   bool
+	hasCommentN int
+	markers     []string // markers passed to HasComment, in order
+}
+
+func (s *recordingSystem) Claim(_ context.Context, ref task.TicketRef, wf string) error {
+	s.log.add("claim:" + ref.Key + ":" + wf)
+	return s.claimErr
+}
+
+func (s *recordingSystem) HasComment(_ context.Context, _ task.Target, marker string) (bool, error) {
+	s.hasCommentN++
+	s.markers = append(s.markers, marker)
+	return s.hasCancel, nil
+}
+
+// fakeExecutor records EnsureRun calls into the shared log.
+type fakeExecutor struct {
+	log     *eventLog
+	ensures []run.Start
+	created bool
+	err     error
+}
+
+func (e *fakeExecutor) EnsureRun(_ context.Context, start run.Start) (bool, error) {
+	e.log.add("ensureRun:" + string(start.ID))
+	e.ensures = append(e.ensures, start)
+	return e.created, e.err
+}
+
+func (e *fakeExecutor) SubmitReport(context.Context, run.ReportRequest) (run.ReportAck, error) {
+	return run.ReportAck{}, nil
+}
+
+func (e *fakeExecutor) CancelRun(context.Context, run.ID, string) error { return nil }
+
+// fakeQueries answers run lookups.
+type fakeQueries struct {
+	byTicket map[string]run.Run
+}
+
+func (q *fakeQueries) GetRun(_ context.Context, id run.ID) (run.Run, error) {
+	for _, r := range q.byTicket {
+		if r.ID == id {
+			return r, nil
+		}
+	}
+	return run.Run{}, errors.New("not found")
+}
+
+func (q *fakeQueries) FindRunByTicket(_ context.Context, ticket string) (run.Run, error) {
+	if r, ok := q.byTicket[ticket]; ok {
+		return r, nil
+	}
+	return run.Run{}, errors.New("not found")
+}
+
+func (q *fakeQueries) ListRuns(context.Context, run.Filter) ([]run.Run, error) { return nil, nil }
+func (q *fakeQueries) HasActiveWorkflow(context.Context, string) (bool, error) { return false, nil }
+func (q *fakeQueries) HasActiveRepo(context.Context, string) (bool, error)     { return false, nil }
+
+func testWorkflow(name string) *workflow.Workflow {
+	return &workflow.Workflow{
+		Name:  name,
+		Repos: []string{"payments"},
+		Nodes: map[string]workflow.Node{
+			"start": {OnSuccess: []workflow.Route{{Target: "coding"}}},
+			"coding": {
+				Type: workflow.NodeAgent, Agent: "build", Description: "work",
+				OnSuccess: []workflow.Route{{Target: "end"}},
+				OnFailure: []workflow.Route{{Target: "coding"}},
+			},
+			"end": {},
+		},
+	}
+}
+
+func testRepo(sys task.System) *repo.Repo {
+	return &repo.Repo{Name: "payments", Path: "/srv/payments", TaskSystem: sys}
+}
+
+func TestUnclaimedTicketClaimedBeforeEnsureRun(t *testing.T) {
+	log := newEventLog()
+	sys := &recordingSystem{log: log}
+	exec := &fakeExecutor{log: log, created: true}
+	m := &run.RunManager{Executor: exec, Runs: &fakeQueries{}}
+	ticket := task.Ticket{ID: "1", Key: "PAY-101", Title: "parent"}
+
+	err := m.EnsureRun(context.Background(), testRepo(sys), testWorkflow("basicFlow"), ticket)
+	if err != nil {
+		t.Fatalf("EnsureRun failed: %v", err)
+	}
+	events := log.all()
+	if len(events) != 2 {
+		t.Fatalf("events = %v, want [claim ensureRun]", events)
+	}
+	// Claim is persisted before the durable run is created.
+	if !strings.HasPrefix(events[0], "claim:") || !strings.Contains(events[0], "basicFlow") {
+		t.Fatalf("first event = %q, want the wf:basicFlow claim", events[0])
+	}
+	if !strings.HasPrefix(events[1], "ensureRun:") {
+		t.Fatalf("second event = %q, want EnsureRun after the claim", events[1])
+	}
+	if !strings.Contains(events[0], "PAY-101") {
+		t.Fatalf("claim event = %q, want ticket PAY-101", events[0])
+	}
+}
+
+func TestClaimedTicketSkipsClaiming(t *testing.T) {
+	log := newEventLog()
+	sys := &recordingSystem{log: log}
+	exec := &fakeExecutor{log: log}
+	m := &run.RunManager{Executor: exec, Runs: &fakeQueries{}}
+	ticket := task.Ticket{ID: "1", Key: "PAY-101", WorkflowClaims: []string{"wf:basicFlow"}}
+
+	err := m.EnsureRun(context.Background(), testRepo(sys), testWorkflow("basicFlow"), ticket)
+	if err != nil {
+		t.Fatalf("EnsureRun failed: %v", err)
+	}
+	for _, e := range log.all() {
+		if strings.HasPrefix(e, "claim:") {
+			t.Fatalf("already-claimed ticket re-claimed: %v", log.all())
+		}
+	}
+	if len(exec.ensures) != 1 {
+		t.Fatalf("executor ensures = %d, want 1 (run still ensured)", len(exec.ensures))
+	}
+}
+
+func TestClaimFailurePreventsRunCreation(t *testing.T) {
+	log := newEventLog()
+	sys := &recordingSystem{log: log, claimErr: errors.New("jira down")}
+	exec := &fakeExecutor{log: log}
+	m := &run.RunManager{Executor: exec, Runs: &fakeQueries{}}
+	ticket := task.Ticket{ID: "1", Key: "PAY-101"}
+
+	err := m.EnsureRun(context.Background(), testRepo(sys), testWorkflow("basicFlow"), ticket)
+	if err == nil {
+		t.Fatal("EnsureRun succeeded despite claim failure")
+	}
+	for _, e := range log.all() {
+		if strings.HasPrefix(e, "ensureRun:") {
+			t.Fatal("run created after claim failure; claim must succeed first")
+		}
+	}
+}
+
+func TestCancellationMarkerSkipsRunCreation(t *testing.T) {
+	// A labeled ticket with a missing run but carrying the
+	// <runID>:cancellation marker must not be recreated.
+	log := newEventLog()
+	sys := &recordingSystem{log: log, hasCancel: true}
+	exec := &fakeExecutor{log: log}
+	m := &run.RunManager{Executor: exec, Runs: &fakeQueries{byTicket: map[string]run.Run{}}}
+	ticket := task.Ticket{ID: "1", Key: "PAY-101", WorkflowClaims: []string{"wf:basicFlow"}}
+
+	err := m.EnsureRun(context.Background(), testRepo(sys), testWorkflow("basicFlow"), ticket)
+	if err != nil {
+		t.Fatalf("EnsureRun failed: %v", err)
+	}
+	for _, e := range log.all() {
+		if strings.HasPrefix(e, "ensureRun:") {
+			t.Fatal("run recreated for cancellation-marked parent; marker must skip creation")
+		}
+	}
+	if sys.hasCommentN == 0 {
+		t.Fatal("Run Manager never checked the cancellation marker before creating a missing claimed run")
+	}
+	// The marker checked is exactly the deterministic <runID>:cancellation.
+	wantMarker := string(identity.NewRunID("payments", "basicFlow", "PAY-101")) + ":cancellation"
+	found := false
+	for _, mk := range sys.markers {
+		if mk == wantMarker {
+			found = true
+		}
+	}
+	if !found {
+		t.Fatalf("cancellation marker checked = %v, want %q", sys.markers, wantMarker)
+	}
+}
+
+func TestDeterministicRunID(t *testing.T) {
+	log := newEventLog()
+	sys := &recordingSystem{log: log}
+	exec := &fakeExecutor{log: log, created: true}
+	m := &run.RunManager{Executor: exec, Runs: &fakeQueries{}}
+	ticket := task.Ticket{ID: "1", Key: "PAY-101"}
+
+	if err := m.EnsureRun(context.Background(), testRepo(sys), testWorkflow("basicFlow"), ticket); err != nil {
+		t.Fatal(err)
+	}
+	want := identity.NewRunID("payments", "basicFlow", "PAY-101")
+	if exec.ensures[0].ID != want {
+		t.Fatalf("run ID = %q, want deterministic %q", exec.ensures[0].ID, want)
+	}
+}
+
+func TestCancelByTicketResolvesActiveRun(t *testing.T) {
+	rid := identity.NewRunID("payments", "basicFlow", "PAY-101")
+	queries := &fakeQueries{byTicket: map[string]run.Run{
+		"PAY-101": {ID: rid, Ticket: task.TicketRef{Key: "PAY-101"}, State: run.StateWaiting},
+	}}
+	exec := &cancelRecorder{}
+	m := &run.RunManager{Executor: exec, Runs: queries}
+
+	if err := m.CancelByTicket(context.Background(), "PAY-101", "no longer needed"); err != nil {
+		t.Fatalf("CancelByTicket failed: %v", err)
+	}
+	if exec.canceled != rid {
+		t.Fatalf("canceled run = %q, want %q", exec.canceled, rid)
+	}
+}
+
+type cancelRecorder struct {
+	fakeExecutor
+	canceled run.ID
+}
+
+func (e *cancelRecorder) CancelRun(_ context.Context, id run.ID, _ string) error {
+	e.canceled = id
+	return nil
+}

package/internal/runner/contract_test.go

@@ -0,0 +1,221 @@
+package runner_test
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/identity"
+	"github.com/rajpopat27/relay-flow/internal/runner"
+)
+
+// 3.7: runner contract tests against a fake runner, per
+// specs/integration-contracts "Runner executes harnesses in ticket-scoped
+// environments" and "Runner terminal titles are stable and minimal".
+
+type fakeRunner struct {
+	envs       map[string]runner.Environment
+	terminals  map[string]runner.Terminal // key: envID/title
+	dead       map[string]bool            // terminal key -> unusable
+	closed     []string
+	cleaned    []string
+	ensureN    int
+	ensureEnvN int
+}
+
+func newFakeRunner() *fakeRunner {
+	return &fakeRunner{
+		envs:      map[string]runner.Environment{},
+		terminals: map[string]runner.Terminal{},
+		dead:      map[string]bool{},
+	}
+}
+
+func spec() runner.RunSpec {
+	return runner.RunSpec{
+		RunID:     identity.NewRunID("payments", "basicFlow", "PAY-101"),
+		RepoName:  "payments",
+		RepoPath:  "/srv/payments",
+		TicketKey: "PAY-101",
+	}
+}
+
+func (f *fakeRunner) DiscoverRepos(context.Context) ([]runner.RepoCandidate, error) {
+	return []runner.RepoCandidate{{Name: "payments", Path: "/srv/payments"}}, nil
+}
+
+func (f *fakeRunner) ValidateRepo(context.Context, string, string) error { return nil }
+
+func (f *fakeRunner) EnsureEnvironment(_ context.Context, s runner.RunSpec) (runner.Environment, error) {
+	f.ensureEnvN++
+	key := string(s.RunID)
+	if env, ok := f.envs[key]; ok {
+		return env, nil
+	}
+	env := runner.Environment{ID: "env-" + key, Path: s.RepoPath + "/.wt/" + s.TicketKey}
+	f.envs[key] = env
+	return env, nil
+}
+
+func (f *fakeRunner) FindTerminal(_ context.Context, env runner.Environment, title string) (runner.Terminal, bool, error) {
+	key := env.ID + "/" + title
+	term, ok := f.terminals[key]
+	if !ok || f.dead[key] {
+		// Only a live usable terminal is returned.
+		return runner.Terminal{}, false, nil
+	}
+	return term, true, nil
+}
+func (f *fakeRunner) InspectTerminal(_ context.Context, term runner.Terminal) (runner.Terminal, bool, error) {
+	for key, current := range f.terminals {
+		if current.ID == term.ID && !f.dead[key] {
+			return current, true, nil
+		}
+	}
+	return runner.Terminal{}, false, nil
+}
+func (f *fakeRunner) SendTerminal(context.Context, runner.Terminal, string) error { return nil }
+func (f *fakeRunner) CreateTerminal(ctx context.Context, env runner.Environment, title string, command runner.Command) (runner.Terminal, error) {
+	return f.EnsureTerminal(ctx, env, title, command)
+}
+
+func (f *fakeRunner) CloseTerminal(_ context.Context, term runner.Terminal) error {
+	for k, v := range f.terminals {
+		if v.ID == term.ID {
+			delete(f.terminals, k)
+		}
+	}
+	f.closed = append(f.closed, term.ID)
+	return nil
+}
+
+func (f *fakeRunner) EnsureTerminal(_ context.Context, env runner.Environment, title string, _ runner.Command) (runner.Terminal, error) {
+	f.ensureN++
+	key := env.ID + "/" + title
+	if term, ok := f.terminals[key]; ok && !f.dead[key] {
+		return term, nil
+	}
+	term := runner.Terminal{ID: "term-" + key, Title: title}
+	f.terminals[key] = term
+	delete(f.dead, key)
+	return term, nil
+}
+
+func (f *fakeRunner) CloseTerminals(_ context.Context, s runner.RunSpec) error {
+	prefix := "env-" + string(s.RunID) + "/"
+	for k := range f.terminals {
+		if strings.HasPrefix(k, prefix) {
+			delete(f.terminals, k)
+			f.closed = append(f.closed, k)
+		}
+	}
+	// Environment/workspace preserved: f.envs untouched.
+	return nil
+}
+
+func (f *fakeRunner) CleanupRun(_ context.Context, s runner.RunSpec) error {
+	_ = f.CloseTerminals(context.Background(), s)
+	delete(f.envs, string(s.RunID))
+	f.cleaned = append(f.cleaned, string(s.RunID))
+	return nil
+}
+
+func TestTerminalTitleIsTicketColonNode(t *testing.T) {
+	f := newFakeRunner()
+	ctx := context.Background()
+	sp := spec()
+	env, err := f.EnsureEnvironment(ctx, sp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	term, err := f.EnsureTerminal(ctx, env, "PAY-101:coding", runner.Command{Executable: "opencode"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if term.Title != "PAY-101:coding" {
+		t.Fatalf("title = %q, want PAY-101:coding", term.Title)
+	}
+	// Title must never carry nodeVisitID, workflow, or agent metadata.
+	visit := identity.NewNodeVisitID()
+	for _, forbidden := range []string{string(visit), "basicFlow", "build"} {
+		if strings.Contains(term.Title, forbidden) {
+			t.Fatalf("title %q contains forbidden metadata %q", term.Title, forbidden)
+		}
+	}
+}
+
+func TestFindTerminalReturnsOnlyLiveUsable(t *testing.T) {
+	f := newFakeRunner()
+	ctx := context.Background()
+	env, _ := f.EnsureEnvironment(ctx, spec())
+	term, _ := f.EnsureTerminal(ctx, env, "PAY-101:coding", runner.Command{})
+
+	got, ok, err := f.FindTerminal(ctx, env, "PAY-101:coding")
+	if err != nil || !ok || got.ID != term.ID {
+		t.Fatalf("FindTerminal = %v,%v,%v; want live terminal", got, ok, err)
+	}
+
+	// A stale/dead record is treated as absent.
+	f.dead[env.ID+"/PAY-101:coding"] = true
+	_, ok, err = f.FindTerminal(ctx, env, "PAY-101:coding")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ok {
+		t.Fatal("FindTerminal returned a dead terminal as usable")
+	}
+}
+
+func TestCloseTerminalsPreservesEnvironment(t *testing.T) {
+	f := newFakeRunner()
+	ctx := context.Background()
+	sp := spec()
+	env, _ := f.EnsureEnvironment(ctx, sp)
+	_, _ = f.EnsureTerminal(ctx, env, "PAY-101:coding", runner.Command{})
+
+	if err := f.CloseTerminals(ctx, sp); err != nil {
+		t.Fatal(err)
+	}
+	if len(f.terminals) != 0 {
+		t.Fatalf("terminals remain after CloseTerminals: %v", f.terminals)
+	}
+	if _, ok := f.envs[string(sp.RunID)]; !ok {
+		t.Fatal("CloseTerminals removed the environment; it must preserve workspace/code")
+	}
+}
+
+func TestCleanupRunRemovesAllRunResources(t *testing.T) {
+	f := newFakeRunner()
+	ctx := context.Background()
+	sp := spec()
+	env, _ := f.EnsureEnvironment(ctx, sp)
+	_, _ = f.EnsureTerminal(ctx, env, "PAY-101:coding", runner.Command{})
+
+	if err := f.CleanupRun(ctx, sp); err != nil {
+		t.Fatal(err)
+	}
+	if len(f.terminals) != 0 {
+		t.Fatalf("terminals remain after CleanupRun: %v", f.terminals)
+	}
+	if _, ok := f.envs[string(sp.RunID)]; ok {
+		t.Fatal("environment remains after CleanupRun; it must remove run-owned resources")
+	}
+}
+
+func TestEnsureIdempotent(t *testing.T) {
+	f := newFakeRunner()
+	ctx := context.Background()
+	sp := spec()
+
+	env1, _ := f.EnsureEnvironment(ctx, sp)
+	env2, _ := f.EnsureEnvironment(ctx, sp)
+	if env1 != env2 {
+		t.Fatalf("EnsureEnvironment not idempotent: %v vs %v", env1, env2)
+	}
+
+	term1, _ := f.EnsureTerminal(ctx, env1, "PAY-101:coding", runner.Command{})
+	term2, _ := f.EnsureTerminal(ctx, env1, "PAY-101:coding", runner.Command{})
+	if term1 != term2 {
+		t.Fatalf("EnsureTerminal not idempotent: %v vs %v", term1, term2)
+	}
+}

package/internal/runner/factory.go

@@ -0,0 +1,65 @@
+package runner
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// Factory constructs a Runner from root runner config. No repo-level runner
+// config exists; the runner resolves internal workspace IDs from the
+// registered repo name and path.
+type Factory func(config.RawValues) (Runner, error)
+
+var (
+	registryMu sync.RWMutex
+	registry   = map[string]Factory{}
+)
+
+// Register adds a runner factory by name. Duplicate registration panics.
+func Register(name string, factory Factory) {
+	registryMu.Lock()
+	defer registryMu.Unlock()
+	if _, exists := registry[name]; exists {
+		panic(fmt.Sprintf("runner: duplicate registration of %q", name))
+	}
+	registry[name] = factory
+}
+
+// New constructs the named runner.
+func New(name string, cfg config.RawValues) (Runner, error) {
+	registryMu.RLock()
+	f, ok := registry[name]
+	registryMu.RUnlock()
+	if !ok {
+		return nil, fmt.Errorf("runner: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return f(cfg)
+}
+
+// ValidateName returns an error listing registered names when name is not
+// a registered plugin. Used by `relay-flow init` to reject unknown plugin
+// selections without constructing a Runner.
+func ValidateName(name string) error {
+	registryMu.RLock()
+	defer registryMu.RUnlock()
+	if _, ok := registry[name]; !ok {
+		return fmt.Errorf("runner: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return nil
+}
+
+// Names returns the registered plugin names sorted.
+func Names() []string {
+	registryMu.RLock()
+	defer registryMu.RUnlock()
+	out := make([]string, 0, len(registry))
+	for name := range registry {
+		out = append(out, name)
+	}
+	sort.Strings(out)
+	return out
+}