relay-flow 0.0.1 → 0.2.0-alpha

package/internal/tasks/jira/jira_test.go

@@ -1,259 +0,0 @@
-package jira
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/rajpopat27/relay-flow/internal/acli"
-	"github.com/rajpopat27/relay-flow/internal/config"
-	"github.com/rajpopat27/relay-flow/internal/tasks"
-)
-
-var testNodes = map[string]config.Node{
-	"coding":    {Agent: "build", When: "In Progress", OnSuccess: "reviewing", OnFailure: "coding"},
-	"reviewing": {Agent: "build", When: "In Review", OnSuccess: "done", OnFailure: "coding"},
-	"done":      {When: "Done"},
-}
-
-func TestClaimLabel(t *testing.T) {
-	if got := claimLabel("xyzTaskFlow"); got != "wf:xyzTaskFlow" {
-		t.Errorf("claimLabel = %q", got)
-	}
-}
-
-func TestBuildJQL(t *testing.T) {
-	cfg := JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task"}}
-	j, err := newJira(cfg, "wf", testNodes, "Jane Doe", "repo:xyz", nil)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	want := `(project = xyz) AND issuetype IN ("Task") AND component = "repo:xyz" AND assignee = "Jane Doe" ORDER BY updated`
-	if j.jql != want {
-		t.Errorf("jql =\n  %q\nwant\n  %q", j.jql, want)
-	}
-}
-
-func TestBuildJQLCentralizedSkipsAssignee(t *testing.T) {
-	cfg := JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task", "Story"}, AssigneeIsAgent: true}
-	j, err := newJira(cfg, "wf", testNodes, "", "repo:xyz", nil)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if strings.Contains(j.jql, "assignee") {
-		t.Errorf("assigneeIsAgent must skip assignee clause: %q", j.jql)
-	}
-	if !strings.Contains(j.jql, `"Task", "Story"`) {
-		t.Errorf("issueTypes list: %q", j.jql)
-	}
-}
-
-func TestConfigValidation(t *testing.T) {
-	base := map[string]any{"query": "project = xyz", "issueTypes": []any{"Task"}}
-	goodAny, err := unmarshalConfig(base)
-	if err != nil {
-		t.Fatalf("valid config rejected: %v", err)
-	}
-	good := goodAny.(JiraConfig)
-	if good.Query != "project = xyz" || len(good.IssueTypes) != 1 {
-		t.Errorf("%+v", good)
-	}
-
-	bad := []struct {
-		name string
-		mut  func(map[string]any)
-		want string
-	}{
-		{"empty query", func(m map[string]any) { m["query"] = "" }, "query"},
-		{"no issueTypes", func(m map[string]any) { delete(m, "issueTypes") }, "issueTypes"},
-		{"ORDER BY in query", func(m map[string]any) { m["query"] = "project = xyz ORDER BY rank" }, "ORDER BY"},
-		{"issuetype in query", func(m map[string]any) { m["query"] = "project = xyz AND issuetype = Bug" }, "issuetype"},
-		{"assignee in query", func(m map[string]any) { m["query"] = "project = xyz AND assignee = bob" }, "assignee"},
-		{"unknown field", func(m map[string]any) { m["bogus"] = 1 }, "bogus"},
-	}
-	for _, tc := range bad {
-		t.Run(tc.name, func(t *testing.T) {
-			m := map[string]any{"query": "project = xyz", "issueTypes": []any{"Task"}}
-			tc.mut(m)
-			if _, err := unmarshalConfig(m); err == nil || !strings.Contains(err.Error(), tc.want) {
-				t.Errorf("err = %v, want mention %q", err, tc.want)
-			}
-		})
-	}
-}
-
-type fakeAcli struct {
-	tickets       []acli.Ticket
-	labelsAdded   []string
-	transitions   []string
-	comments      []string
-	views         map[string]acli.Ticket
-	transitionErr error
-}
-
-func (f *fakeAcli) Search(jql string) ([]acli.Ticket, error) { return f.tickets, nil }
-func (f *fakeAcli) AddLabel(key string, existing []string, label string) error {
-	f.labelsAdded = append(f.labelsAdded, key+":"+label)
-	return nil
-}
-func (f *fakeAcli) Transition(key, status string) error {
-	f.transitions = append(f.transitions, key+":"+status)
-	return f.transitionErr
-}
-func (f *fakeAcli) Comment(key, body string) error {
-	f.comments = append(f.comments, key+":"+body)
-	return nil
-}
-func (f *fakeAcli) View(key string) (acli.Ticket, error) {
-	t, ok := f.views[key]
-	if !ok {
-		t = acli.Ticket{Key: key}
-	}
-	return t, nil
-}
-
-func mustJira(t *testing.T, ac aclier) *jiraTasks {
-	t.Helper()
-	j, err := newJira(JiraConfig{Query: "project = xyz", IssueTypes: []string{"Task"}}, "wf", testNodes, "", "repo:xyz", ac)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	return j
-}
-
-func TestListMapsStateToNode(t *testing.T) {
-	fa := &fakeAcli{tickets: []acli.Ticket{
-		{Key: "XYZ-1", Summary: "s", Status: "In Progress"},
-		{Key: "XYZ-2", Summary: "s", Status: "In Review", Labels: []string{"wf:otherFlow"}},
-		{Key: "XYZ-3", Summary: "s", Status: "Backlog"},
-	}}
-	j := mustJira(t, fa)
-	got, err := j.List()
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(got) != 3 {
-		t.Fatalf("len = %d", len(got))
-	}
-	if got[0].Node != "coding" || got[0].ClaimedBy != "" {
-		t.Errorf("t1 = %+v", got[0])
-	}
-	if got[1].Node != "reviewing" || got[1].ClaimedBy != "otherFlow" {
-		t.Errorf("t2 = %+v", got[1])
-	}
-	if got[2].Node != "" {
-		t.Errorf("unmapped state must yield empty Node: %+v", got[2])
-	}
-}
-
-func TestClaim(t *testing.T) {
-	fa := &fakeAcli{views: map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Labels: []string{"existing"}}}}
-	j := mustJira(t, fa)
-	err := j.Claim(tasksTicket("XYZ-1"))
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(fa.labelsAdded) != 1 || fa.labelsAdded[0] != "XYZ-1:wf:wf" {
-		t.Errorf("labelsAdded = %v", fa.labelsAdded)
-	}
-}
-
-func TestReportTransitions(t *testing.T) {
-	fa := &fakeAcli{views: map[string]acli.Ticket{
-		"XYZ-1": {Key: "XYZ-1", Status: "In Progress"},
-	}}
-	j := mustJira(t, fa)
-	err := j.Report(tasksTicket("XYZ-1"), "success", "reviewing", "did the thing")
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(fa.transitions) != 1 || fa.transitions[0] != "XYZ-1:In Review" {
-		t.Errorf("transitions = %v", fa.transitions)
-	}
-	if len(fa.comments) != 1 || !strings.Contains(fa.comments[0], "did the thing") {
-		t.Errorf("comments = %v", fa.comments)
-	}
-}
-
-func TestReportSelfLoopCommentsOnly(t *testing.T) {
-	fa := &fakeAcli{views: map[string]acli.Ticket{
-		"XYZ-1": {Key: "XYZ-1", Status: "In Progress"},
-	}}
-	j := mustJira(t, fa)
-	// coding onFailure = coding: target state == current state.
-	err := j.Report(tasksTicket("XYZ-1"), "failure", "coding", "still broken")
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(fa.transitions) != 0 {
-		t.Errorf("self-loop must not transition: %v", fa.transitions)
-	}
-	if len(fa.comments) != 1 {
-		t.Errorf("self-loop must comment: %v", fa.comments)
-	}
-}
-
-func TestReportUnknownTargetNode(t *testing.T) {
-	fa := &fakeAcli{views: map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Status: "In Progress"}}}
-	j := mustJira(t, fa)
-	if err := j.Report(tasksTicket("XYZ-1"), "success", "nowhere", "x"); err == nil ||
-		!strings.Contains(err.Error(), "unknown node") {
-		t.Errorf("err = %v", err)
-	}
-}
-
-func TestProjectKeyFromQuery(t *testing.T) {
-	got, err := ProjectKeyFromQuery("project = xyz AND foo = bar")
-	if err != nil || got != "xyz" {
-		t.Errorf("got %q err %v", got, err)
-	}
-	got, err = ProjectKeyFromQuery(`PROJECT = "ABC"`)
-	if err != nil || got != "ABC" {
-		t.Errorf("got %q err %v", got, err)
-	}
-	if _, err = ProjectKeyFromQuery("foo = bar"); err == nil {
-		t.Error("expected error for missing project")
-	}
-}
-
-func TestValidateStates(t *testing.T) {
-	fa := &fakeValidator{good: map[string]bool{"In Progress": true, "In Review": true}}
-	bad, err := ValidateStates(fa, testNodes, "xyz")
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if len(bad) != 1 || bad[0] != "Done" {
-		t.Errorf("bad = %v", bad)
-	}
-}
-
-type fakeValidator struct{ good map[string]bool }
-
-func (f *fakeValidator) ValidateStatus(projectKey, status string) error {
-	if f.good[status] {
-		return nil
-	}
-	return errInvalidStatus
-}
-
-var errInvalidStatus = errorString("invalid status")
-
-type errorString string
-
-func (e errorString) Error() string { return string(e) }
-
-func tasksTicket(key string) tasks.Ticket { return tasks.Ticket{Key: key} }
-
-func TestReportTransitionFailurePropagates(t *testing.T) {
-	fa := &fakeAcli{
-		views:         map[string]acli.Ticket{"XYZ-1": {Key: "XYZ-1", Status: "In Progress"}},
-		transitionErr: errorString("No allowed transitions found for given status"),
-	}
-	j := mustJira(t, fa)
-	err := j.Report(tasks.Ticket{Key: "XYZ-1"}, "success", "reviewing", "x")
-	if err == nil || !strings.Contains(err.Error(), "No allowed transitions") {
-		t.Errorf("transition failure must propagate, got %v", err)
-	}
-	if len(fa.comments) != 0 {
-		t.Errorf("no comment on failed transition: %v", fa.comments)
-	}
-}

package/internal/tasks/jira/jql_test.go

@@ -1,16 +0,0 @@
-package jira
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestDistributedJQLHasAssignee(t *testing.T) {
-	j, err := newJira(JiraConfig{Query: "project = XYZ", IssueTypes: []string{"Task"}}, "wf", testNodes, "Jane Doe", "xyz-repo", nil)
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	if !strings.Contains(j.jql, `assignee = "Jane Doe"`) {
-		t.Errorf("distributed JQL missing assignee: %q", j.jql)
-	}
-}

package/internal/tasks/tasks.go

@@ -1,90 +0,0 @@
-// Package tasks defines the ticket-system plug point. Jira ships built in
-// (internal/tasks/jira); beads/linear/github adapters register the same
-// way via init() — the database/sql driver pattern: import to register,
-// then resolve by type name from the workflow YAML's `tasks.type`.
-package tasks
-
-import (
-	"fmt"
-	"sort"
-	"sync"
-
-	"github.com/rajpopat27/relay-flow/internal/config"
-)
-
-// Ticket is one unit of work as seen by the daemon. Adapters fill Node by
-// reverse-mapping the ticket's tracker state through the workflow's node
-// `when` values ("" = unmapped state), and ClaimedBy from claim labels
-// ("" = unclaimed).
-type Ticket struct {
-	Key       string
-	Summary   string
-	Node      string
-	ClaimedBy string
-}
-
-// Tasks is the tracker adapter interface: list candidate tickets, claim
-// one, report an outcome. One List call per poll cycle per workflow.
-type Tasks interface {
-	List() ([]Ticket, error)
-	Claim(t Ticket) error
-	// Report records the agent outcome: transitions the ticket to the
-	// target node's tracker state (adapter resolves it) and posts the
-	// summary. Self-loop (target state == current) → comment only.
-	Report(t Ticket, outcome, targetNode, summary string) error
-}
-
-// Factory builds an adapter instance for one submitted workflow.
-type Factory struct {
-	// UnmarshalConfig strictly decodes the YAML's tasks.config map into
-	// the adapter's own config struct.
-	UnmarshalConfig func(map[string]any) (any, error)
-	// New builds the adapter. wfName is the workflow identity (claim
-	// labels); nodes carry the `when` state map; assignee is the machine
-	// user's tracker identity ("" when the adapter doesn't need it);
-	// repoName is the repo's display name (tracker-side component/label
-	// scoping; "" when the adapter doesn't scope by repo).
-	New func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error)
-}
-
-var (
-	mu        sync.RWMutex
-	factories = map[string]Factory{}
-)
-
-// Register makes an adapter available under `type: <name>`. Called from
-// adapter init(); panics on duplicate names (programmer error).
-func Register(name string, f Factory) {
-	mu.Lock()
-	defer mu.Unlock()
-	if _, dup := factories[name]; dup {
-		panic("tasks: duplicate adapter registration " + name)
-	}
-	factories[name] = f
-}
-
-// New resolves a tasks adapter by type name and builds an instance.
-func New(typeName string, rawCfg map[string]any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error) {
-	mu.RLock()
-	f, ok := factories[typeName]
-	mu.RUnlock()
-	if !ok {
-		return nil, fmt.Errorf("unknown tasks type %q (registered: %v)", typeName, registered())
-	}
-	cfg, err := f.UnmarshalConfig(rawCfg)
-	if err != nil {
-		return nil, fmt.Errorf("tasks type %q config: %w", typeName, err)
-	}
-	return f.New(cfg, wfName, nodes, assignee, repoName)
-}
-
-func registered() []string {
-	mu.RLock()
-	defer mu.RUnlock()
-	names := make([]string, 0, len(factories))
-	for n := range factories {
-		names = append(names, n)
-	}
-	sort.Strings(names)
-	return names
-}

package/internal/tasks/tasks_test.go

@@ -1,91 +0,0 @@
-package tasks
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/rajpopat27/relay-flow/internal/config"
-)
-
-func testNodes() map[string]config.Node {
-	return map[string]config.Node{
-		"coding":    {Agent: "build", When: "In Progress", OnSuccess: "reviewing", OnFailure: "coding"},
-		"reviewing": {Agent: "build", When: "In Review", OnSuccess: "done", OnFailure: "coding"},
-		"done":      {When: "Done"},
-	}
-}
-
-type fakeTasks struct {
-	listed  []Ticket
-	claims  []string
-	reports []string
-}
-
-func (f *fakeTasks) List() ([]Ticket, error) { return f.listed, nil }
-func (f *fakeTasks) Claim(t Ticket) error {
-	f.claims = append(f.claims, t.Key)
-	return nil
-}
-func (f *fakeTasks) Report(t Ticket, outcome, targetNode, summary string) error {
-	f.reports = append(f.reports, t.Key+":"+outcome+":"+targetNode)
-	return nil
-}
-
-func TestRegistryNew(t *testing.T) {
-	fake := &fakeTasks{}
-	Register("fake", Factory{
-		UnmarshalConfig: func(m map[string]any) (any, error) {
-			if m["bad"] != nil {
-				return nil, errFakeConfig
-			}
-			return m, nil
-		},
-		New: func(cfg any, wfName string, nodes map[string]config.Node, assignee, repoName string) (Tasks, error) {
-			if repoName != "repo:xyz" {
-				t.Errorf("repoName = %q", repoName)
-			}
-			if wfName == "" {
-				t.Error("wfName empty")
-			}
-			if nodes["coding"].When != "In Progress" {
-				t.Error("nodes not passed")
-			}
-			return fake, nil
-		},
-	})
-
-	tk, err := New("fake", map[string]any{"k": "v"}, "xyzFlow", testNodes(), "Jane Doe", "repo:xyz")
-	if err != nil {
-		t.Fatalf("%v", err)
-	}
-	tk.Claim(Ticket{Key: "XYZ-1"})
-	if len(fake.claims) != 1 || fake.claims[0] != "XYZ-1" {
-		t.Errorf("claims = %v", fake.claims)
-	}
-
-	if _, err := New("nonexistent-adapter", nil, "w", nil, "", ""); err == nil ||
-		!strings.Contains(err.Error(), "unknown tasks type") || !strings.Contains(err.Error(), "fake") {
-		t.Errorf("unknown adapter error = %v", err)
-	}
-
-	if _, err := New("fake", map[string]any{"bad": true}, "w", testNodes(), "", ""); err == nil || !strings.Contains(err.Error(), "bad config") {
-		t.Errorf("config unmarshal err = %v", err)
-	}
-}
-
-var errFakeConfig = errorString("bad config")
-
-type errorString string
-
-func (e errorString) Error() string { return string(e) }
-
-func TestDuplicateRegisterPanics(t *testing.T) {
-	defer func() {
-		if recover() == nil {
-			t.Fatal("expected panic on duplicate registration")
-		}
-	}()
-	f := Factory{}
-	Register("dup", f)
-	Register("dup", f)
-}