relay-flow 0.0.1 → 0.2.0-alpha

package/internal/server/shutdown_test.go

@@ -0,0 +1,116 @@
+package server_test
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"testing"
+	"time"
+)
+
+// 3.37: graceful shutdown per specs/workflow-repo-management "Graceful
+// shutdown is bounded". Uses the handler fixture on a real Unix socket so a
+// restart on the same dir resumes the same state.
+
+func TestShutdownStopsAcceptingWithinBound(t *testing.T) {
+	dir := t.TempDir()
+	c, shutdown := startHandlerOnSocket(t, dir, &fakeServices{})
+
+	if _, err := c.Get("http://unix/workflows"); err != nil {
+		t.Fatalf("pre-shutdown request failed: %v", err)
+	}
+
+	start := time.Now()
+	shutdown()
+	if elapsed := time.Since(start); elapsed > 35*time.Second {
+		t.Fatalf("shutdown took %v, exceeding the bounded 30s wait", elapsed)
+	}
+
+	if _, err := c.Get("http://unix/workflows"); err == nil {
+		t.Fatal("server still accepting requests after shutdown")
+	}
+}
+
+func TestShutdownWaitsForRunningCall(t *testing.T) {
+	dir := t.TempDir()
+	release := make(chan struct{})
+	c, shutdown := startHandlerOnSocket(t, dir, &fakeServices{slowReport: release})
+
+	done := make(chan error, 1)
+	go func() {
+		resp, err := c.Post("http://unix/reports", "application/json", slowReportBody(t))
+		if err == nil {
+			resp.Body.Close()
+		}
+		done <- err
+	}()
+	time.Sleep(100 * time.Millisecond) // let the slow request start
+
+	stopped := make(chan struct{})
+	go func() { shutdown(); close(stopped) }()
+
+	// While the report is in flight, shutdown must be waiting.
+	select {
+	case <-stopped:
+		t.Fatal("shutdown returned while a call was still running")
+	case <-time.After(300 * time.Millisecond):
+	}
+
+	// Let the running call return; shutdown then completes within the bound.
+	close(release)
+	start := time.Now()
+	select {
+	case <-stopped:
+	case <-time.After(35 * time.Second):
+		t.Fatal("shutdown did not complete after the running call returned")
+	}
+	if err := <-done; err != nil {
+		t.Fatalf("running call interrupted by shutdown: %v", err)
+	}
+	if elapsed := time.Since(start); elapsed > 35*time.Second {
+		t.Fatalf("shutdown exceeded the bounded wait: %v", elapsed)
+	}
+}
+
+func TestRestartOnSameStateResumes(t *testing.T) {
+	// Same backing services across shutdown+restart resume the same state.
+	// The fake services instance is shared so its store survives the restart.
+	dir := t.TempDir()
+	shared := &fakeServices{}
+	c1, shutdown1 := startHandlerOnSocket(t, dir, shared)
+
+	// Submit a workflow so there is state. POST /workflows body IS raw YAML.
+	yamlBody := "name: basicFlow\nrepos: [payments]\nnodes:\n  start: {onSuccess: [{target: end}]}\n  end: {}\n"
+	resp, err := c1.Post("http://unix/workflows", "application/yaml", bytes.NewReader([]byte(yamlBody)))
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp.Body.Close()
+	shutdown1()
+
+	// Restart on the same dir with the SAME services; the workflow persists.
+	// Durable unfinished-run resume across restart is the engine's
+	// responsibility and is covered by the goworkflows same-db restart tests
+	// (TestVisitIDStableAcrossNormalRestart / crash tests); the server layer
+	// resumes serving the same backing state.
+	c2, shutdown2 := startHandlerOnSocket(t, dir, shared)
+	defer shutdown2()
+	code, env := do(t, c2, http.MethodGet, "http://unix/workflows", nil)
+	if code != http.StatusOK || !env.OK {
+		t.Fatalf("restart list: code=%d env=%+v", code, env)
+	}
+	var wfs []map[string]any
+	if err := json.Unmarshal(env.Data, &wfs); err != nil || len(wfs) != 1 {
+		t.Fatalf("state not resumed after restart: data=%s err=%v", env.Data, err)
+	}
+}
+
+func slowReportBody(t *testing.T) *bytes.Reader {
+	t.Helper()
+	return bytes.NewReader([]byte(`{"runId":"r","node":"coding","reportId":"s:m","report":{"status":"success","nextStep":"end","summary":{"completed":"x","commits":"abc123","notCompleted":"None","issuesDiscovered":"None","verification":"x","notes":"None"},"feedback":{"reasonForNextStep":"None","requiredActions":"None","relevantContext":"None","expectedResult":"None"}}}`))
+}
+
+// The server.sock ownership/mode is set by the serve startup path (5.5), which
+// binds and chmods the socket; server.New returns only an http.Handler and does
+// not create sockets. The 0600 assertion lives in cmd/relay-flow/commands_test.go
+// (TestServerSocketIsOwnerOnly) which exercises the serve fixture. See 3.29.

package/internal/task/contract_test.go

@@ -0,0 +1,223 @@
+package task_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/task"
+)
+
+// 3.6: task-system contract tests against a fake adapter, per
+// specs/integration-contracts. The fake implements task.System and the
+// tests assert the contract shape and primitive separation.
+
+// fakeSystem is a minimal in-memory task.System used by contract tests. It
+// holds a mixed backing store (active parents, mailbox subtasks, completed
+// parents) and Poll returns only active parents, per the contract.
+type fakeSystem struct {
+	all       []storedTicket // mixed backing store
+	mailboxes map[string]task.Mailbox
+	completed []string
+	comments  []commentCall
+	applied   []applyCall
+	resets    []string
+}
+
+type storedTicket struct {
+	ticket    task.Ticket
+	isMailbox bool
+	active    bool
+}
+
+type commentCall struct {
+	Target task.Target
+	Body   string
+	Marker string
+}
+
+type applyCall struct {
+	Target     task.Target
+	TaskConfig config.RawValues
+}
+
+func newFakeSystem() *fakeSystem {
+	return &fakeSystem{mailboxes: map[string]task.Mailbox{}}
+}
+
+func (f *fakeSystem) Poll(context.Context) ([]task.Ticket, error) {
+	var out []task.Ticket
+	for _, st := range f.all {
+		if st.active && !st.isMailbox {
+			out = append(out, st.ticket)
+		}
+	}
+	return out, nil
+}
+
+func (f *fakeSystem) CompileFilter(config.RawValues) (func(task.Ticket) bool, error) {
+	return func(task.Ticket) bool { return true }, nil
+}
+
+func (f *fakeSystem) Claim(context.Context, task.TicketRef, string) error { return nil }
+
+func (f *fakeSystem) ValidateConfig(context.Context, config.RawValues, map[string]config.RawValues) error {
+	return nil
+}
+
+func (f *fakeSystem) EnsureMailboxes(_ context.Context, _ task.TicketRef, _ string, specs []task.MailboxSpec) (map[string]task.Mailbox, error) {
+	for _, s := range specs {
+		if _, ok := f.mailboxes[s.Node]; !ok {
+			f.mailboxes[s.Node] = task.Mailbox{ID: "mb-" + s.Node, Key: "PAY-" + s.Node, Node: s.Node}
+		}
+	}
+	out := map[string]task.Mailbox{}
+	for _, s := range specs {
+		out[s.Node] = f.mailboxes[s.Node]
+	}
+	return out, nil
+}
+
+func (f *fakeSystem) ApplyTaskConfig(_ context.Context, target task.Target, cfg config.RawValues) error {
+	f.applied = append(f.applied, applyCall{Target: target, TaskConfig: cfg})
+	return nil
+}
+
+func (f *fakeSystem) CompleteMailbox(_ context.Context, mb task.Mailbox) error {
+	f.completed = append(f.completed, mb.Key)
+	return nil
+}
+
+func (f *fakeSystem) HasComment(_ context.Context, _ task.Target, marker string) (bool, error) {
+	for _, c := range f.comments {
+		if c.Marker == marker {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+func (f *fakeSystem) Comment(_ context.Context, target task.Target, body, marker string) error {
+	f.comments = append(f.comments, commentCall{Target: target, Body: body, Marker: marker})
+	return nil
+}
+
+func (f *fakeSystem) ResetForRecovery(_ context.Context, parent task.TicketRef, _ []task.Mailbox, _ config.RawValues) error {
+	f.resets = append(f.resets, parent.Key)
+	return nil
+}
+
+func TestPollReturnsActiveParentsOnly(t *testing.T) {
+	f := newFakeSystem()
+	// Mixed backing store: an active parent, a mailbox subtask that also
+	// carries the wf: label, and a completed (inactive) parent.
+	f.all = []storedTicket{
+		{ticket: task.Ticket{ID: "1", Key: "PAY-101", Title: "parent", WorkflowClaims: []string{"wf:basicFlow"}}, active: true},
+		{ticket: task.Ticket{ID: "2", Key: "PAY-102", Title: "PAY-101:coding", WorkflowClaims: []string{"wf:basicFlow"}}, isMailbox: true, active: true},
+		{ticket: task.Ticket{ID: "3", Key: "PAY-103", Title: "done parent"}, active: false},
+	}
+	f.mailboxes["coding"] = task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
+
+	got, err := f.Poll(context.Background())
+	if err != nil {
+		t.Fatalf("Poll failed: %v", err)
+	}
+	if len(got) != 1 || got[0].Key != "PAY-101" {
+		t.Fatalf("Poll = %+v, want only the active parent PAY-101", got)
+	}
+	for _, ticket := range got {
+		if ticket.Key == "PAY-102" {
+			t.Fatal("Poll returned a mailbox subtask as a run candidate")
+		}
+		if ticket.Key == "PAY-103" {
+			t.Fatal("Poll returned an inactive/completed parent")
+		}
+	}
+}
+
+func TestEnsureMailboxesFindsExistingCreatesOnlyMissing(t *testing.T) {
+	f := newFakeSystem()
+	parent := task.TicketRef{ID: "1", Key: "PAY-101", Title: "parent"}
+	specs := []task.MailboxSpec{
+		{Node: "exploration", Title: "PAY-101:exploration", Description: "explore"},
+		{Node: "coding", Title: "PAY-101:coding", Description: "code"},
+	}
+
+	first, err := f.EnsureMailboxes(context.Background(), parent, "basicFlow", specs)
+	if err != nil {
+		t.Fatalf("EnsureMailboxes failed: %v", err)
+	}
+	if len(first) != 2 {
+		t.Fatalf("EnsureMailboxes returned %d mailboxes, want 2", len(first))
+	}
+
+	// Second call: finds existing, creates none.
+	second, err := f.EnsureMailboxes(context.Background(), parent, "basicFlow", specs)
+	if err != nil {
+		t.Fatalf("EnsureMailboxes (repeat) failed: %v", err)
+	}
+	for node, mb := range first {
+		if second[node] != mb {
+			t.Fatalf("node %s: mailbox %v changed to %v on repeat; must be reused", node, mb, second[node])
+		}
+	}
+
+	// Add a node: only the missing one is created.
+	specs = append(specs, task.MailboxSpec{Node: "review", Title: "PAY-101:review", Description: "review"})
+	third, err := f.EnsureMailboxes(context.Background(), parent, "basicFlow", specs)
+	if err != nil {
+		t.Fatalf("EnsureMailboxes (extended) failed: %v", err)
+	}
+	if len(third) != 3 {
+		t.Fatalf("EnsureMailboxes returned %d, want complete map of 3", len(third))
+	}
+	if third["exploration"] != first["exploration"] || third["coding"] != first["coding"] {
+		t.Fatal("existing mailboxes were recreated instead of found")
+	}
+	if third["review"].Node != "review" {
+		t.Fatalf("missing mailbox not created: %+v", third["review"])
+	}
+}
+
+func TestCompleteMailboxIsNarrow(t *testing.T) {
+	f := newFakeSystem()
+	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
+	if err := f.CompleteMailbox(context.Background(), mb); err != nil {
+		t.Fatalf("CompleteMailbox failed: %v", err)
+	}
+	if len(f.completed) != 1 || f.completed[0] != "PAY-102" {
+		t.Fatalf("completed = %v", f.completed)
+	}
+	// CompleteMailbox performs no comment/routing/runner work.
+	if len(f.comments) != 0 {
+		t.Fatalf("CompleteMailbox wrote comments: %v", f.comments)
+	}
+	if len(f.applied) != 0 {
+		t.Fatalf("CompleteMailbox applied task config: %v", f.applied)
+	}
+}
+
+func TestSeparatePrimitives(t *testing.T) {
+	// Compile-time: the System interface exposes each primitive separately.
+	var sys task.System = newFakeSystem()
+	ctx := context.Background()
+	parent := task.TicketRef{ID: "1", Key: "PAY-101"}
+	mb := task.Mailbox{ID: "2", Key: "PAY-102", Node: "coding"}
+	target := task.Target{Parent: parent, Mailbox: &mb}
+
+	if err := sys.ApplyTaskConfig(ctx, target, config.RawValues{}); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.CompleteMailbox(ctx, mb); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := sys.HasComment(ctx, target, "m"); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.Comment(ctx, target, "body", "m"); err != nil {
+		t.Fatal(err)
+	}
+	if err := sys.ResetForRecovery(ctx, parent, []task.Mailbox{mb}, config.RawValues{}); err != nil {
+		t.Fatal(err)
+	}
+}

package/internal/task/factory.go

@@ -0,0 +1,103 @@
+package task
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strings"
+	"sync"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// RepoSpec carries the registration values used to construct a repo-bound
+// task System.
+type RepoSpec struct {
+	Name       string
+	Path       string
+	RootConfig config.RawValues
+	RepoConfig config.RawValues
+}
+
+// Factory constructs a task System. RequiredRepoKeys returns the explicit
+// repo YAML keys needed at registration. TaskScopeKey derives an opaque
+// canonical physical task scope (such as Jira site/project/component) used
+// to reject duplicate scope registration.
+type Factory struct {
+	RequiredRepoKeys func() []string
+	TaskScopeKey     func(rootConfig, repoConfig config.RawValues) (string, error)
+	New              func(context.Context, RepoSpec) (System, error)
+}
+
+var (
+	registryMu sync.RWMutex
+	registry   = map[string]Factory{}
+)
+
+// Register adds a task 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("task: duplicate registration of %q", name))
+	}
+	registry[name] = factory
+}
+
+func lookup(name string) (Factory, error) {
+	registryMu.RLock()
+	defer registryMu.RUnlock()
+	f, ok := registry[name]
+	if !ok {
+		return Factory{}, fmt.Errorf("task: unknown plugin %q (registered: %s)", name, strings.Join(Names(), ", "))
+	}
+	return f, nil
+}
+
+// New constructs the repo-bound task System for the named plugin.
+func New(ctx context.Context, name string, spec RepoSpec) (System, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return nil, err
+	}
+	return f.New(ctx, spec)
+}
+
+// RequiredRepoKeys returns the repo YAML keys the named plugin requires at
+// registration.
+func RequiredRepoKeys(name string) ([]string, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return nil, err
+	}
+	return f.RequiredRepoKeys(), nil
+}
+
+// TaskScopeKey derives the canonical task scope for the named plugin.
+func TaskScopeKey(name string, rootConfig, repoConfig config.RawValues) (string, error) {
+	f, err := lookup(name)
+	if err != nil {
+		return "", err
+	}
+	return f.TaskScopeKey(rootConfig, repoConfig)
+}
+
+// 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 System.
+func ValidateName(name string) error {
+	_, err := lookup(name)
+	return err
+}
+
+// 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
+}