relay-flow 0.0.1 → 0.2.0-alpha

package/internal/config/machine_test.go

@@ -0,0 +1,248 @@
+package config_test
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+	"github.com/rajpopat27/relay-flow/internal/paths"
+)
+
+// 3.29: machine config per specs/workflow-repo-management "Machine config
+// stores global settings and registered repos" and "Global defaults are
+// deterministic".
+
+func TestLoadMachineDefaults(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	yaml := `
+taskPlugin: jira
+runnerPlugin: orca
+harnessPlugin: opencode
+`
+	if err := os.WriteFile(path, []byte(yaml), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cfg, err := config.LoadMachine(path)
+	if err != nil {
+		t.Fatalf("LoadMachine failed: %v", err)
+	}
+	if cfg.PollIntervalSeconds != 15 {
+		t.Fatalf("PollIntervalSeconds = %d, want default 15", cfg.PollIntervalSeconds)
+	}
+	if cfg.CompletedRunRetentionDays != 30 {
+		t.Fatalf("CompletedRunRetentionDays = %d, want default 30", cfg.CompletedRunRetentionDays)
+	}
+	if !cfg.KeepTerminalsAlive {
+		t.Fatal("KeepTerminalsAlive = false, want default true")
+	}
+	if !cfg.KeepSessionsAlive {
+		t.Fatal("KeepSessionsAlive = false, want default true")
+	}
+}
+
+func TestLoadMachineValidatesRuntimeKeepSettings(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.yaml")
+	invalid := "taskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\nkeepTerminalsAlive: true\nkeepSessionsAlive: false\n"
+	if err := os.WriteFile(path, []byte(invalid), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := config.LoadMachine(path); err == nil || !strings.Contains(err.Error(), "keepTerminalsAlive requires keepSessionsAlive") {
+		t.Fatalf("invalid keep settings error = %v", err)
+	}
+
+	valid := "taskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\nkeepTerminalsAlive: false\nkeepSessionsAlive: false\n"
+	if err := os.WriteFile(path, []byte(valid), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cfg, err := config.LoadMachine(path)
+	if err != nil || cfg.KeepSessionsAlive {
+		t.Fatalf("explicit session cleanup = %+v, %v", cfg, err)
+	}
+
+	keepSession := "taskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\nkeepTerminalsAlive: false\nkeepSessionsAlive: true\n"
+	if err := os.WriteFile(path, []byte(keepSession), 0600); err != nil {
+		t.Fatal(err)
+	}
+	cfg, err = config.LoadMachine(path)
+	if err != nil || cfg.KeepTerminalsAlive || !cfg.KeepSessionsAlive {
+		t.Fatalf("explicit terminal cleanup with session retention = %+v, %v", cfg, err)
+	}
+}
+
+func TestLoadMachineRejectsNonPositiveGlobals(t *testing.T) {
+	for _, tc := range []struct{ name, yaml string }{
+		{"zero interval", "pollIntervalSeconds: 0\ntaskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\n"},
+		{"negative interval", "pollIntervalSeconds: -5\ntaskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\n"},
+		{"zero retention", "completedRunRetentionDays: 0\ntaskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\n"},
+		{"negative retention", "completedRunRetentionDays: -1\ntaskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\n"},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "config.yaml")
+			if err := os.WriteFile(path, []byte(tc.yaml), 0600); err != nil {
+				t.Fatal(err)
+			}
+			if _, err := config.LoadMachine(path); err == nil {
+				t.Fatal("non-positive global accepted")
+			}
+		})
+	}
+}
+
+func TestLoadMachineRejectsUnknownFields(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "config.yaml")
+	yaml := `
+taskPlugin: jira
+runnerPlugin: orca
+harnessPlugin: opencode
+unknownField: x
+repos:
+  payments:
+    path: /srv/payments
+    bogusRepoField: 1
+`
+	if err := os.WriteFile(path, []byte(yaml), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := config.LoadMachine(path); err == nil {
+		t.Fatal("unknown root/repo fields accepted by strict decode")
+	}
+}
+
+func TestSaveAndLoadRoundTrip(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	cfg := &config.Machine{
+		TaskPlugin:    "jira",
+		RunnerPlugin:  "orca",
+		HarnessPlugin: "opencode",
+		Repos: map[string]config.Repo{
+			"payments": {Path: "/srv/payments", TaskConfig: config.RawValues{"project": "PAY"}},
+		},
+	}
+	if err := config.SaveMachine(path, cfg); err != nil {
+		t.Fatalf("SaveMachine failed: %v", err)
+	}
+	// Owner-only permissions.
+	fi, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fi.Mode().Perm() != 0600 {
+		t.Fatalf("config mode = %o, want 0600", fi.Mode().Perm())
+	}
+
+	loaded, err := config.LoadMachine(path)
+	if err != nil {
+		t.Fatalf("LoadMachine failed: %v", err)
+	}
+	if loaded.TaskPlugin != "jira" || loaded.Repos["payments"].Path != "/srv/payments" {
+		t.Fatalf("round trip mismatch: %+v", loaded)
+	}
+	if loaded.Repos["payments"].TaskConfig["project"] != "PAY" {
+		t.Fatalf("repo taskConfig lost: %+v", loaded.Repos["payments"].TaskConfig)
+	}
+}
+
+func TestRepoEntryHoldsOnlyPathAndTaskConfig(t *testing.T) {
+	// Repo entries hold only path and taskConfig; unknown keys are rejected
+	// by strict decode (covered above). Compile-time shape check.
+	var r config.Repo
+	_ = r.Path
+	_ = r.TaskConfig
+}
+
+func TestFixedFilesystemLayoutAndPermissions(t *testing.T) {
+	// Fixed layout: every artifact lives under the relay-flow root with the
+	// documented filename. Assert the fixed names without coupling to the
+	// ambient user home.
+	p, err := paths.ForUserHome()
+	if err != nil {
+		t.Fatal(err)
+	}
+	for name, got := range map[string]string{
+		"Root":      p.Root,
+		"Config":    p.Config,
+		"Workflows": p.Workflows,
+		"Database":  p.Database,
+		"Socket":    p.Socket,
+		"Lock":      p.Lock,
+		"ServerLog": p.ServerLog,
+		"PluginLog": p.PluginLog,
+	} {
+		if got == "" {
+			t.Fatalf("%s is empty", name)
+		}
+	}
+	// Fixed filenames under the root.
+	if filepath.Base(p.Config) != "config.yaml" ||
+		filepath.Base(p.Database) != "state.db" ||
+		filepath.Base(p.Socket) != "server.sock" ||
+		filepath.Base(p.Lock) != "server.lock" ||
+		filepath.Base(p.ServerLog) != "server.log" ||
+		filepath.Base(p.PluginLog) != "plugin.log" ||
+		filepath.Base(p.Workflows) != "workflows" {
+		t.Fatalf("non-fixed layout: %+v", p)
+	}
+	// Everything is under the root.
+	for _, sub := range []string{p.Config, p.Database, p.Socket, p.Lock, p.ServerLog, p.PluginLog, p.Workflows} {
+		if !strings.HasPrefix(sub, p.Root) {
+			t.Fatalf("%q not under root %q", sub, p.Root)
+		}
+	}
+
+	// Permissions on a controlled root: root 0700, logs 0600.
+	tmp := filepath.Join(t.TempDir(), ".relay-flow")
+	tp := p
+	tp.Root = tmp
+	tp.Config = filepath.Join(tmp, "config.yaml")
+	tp.Workflows = filepath.Join(tmp, "workflows")
+	tp.Database = filepath.Join(tmp, "state.db")
+	tp.Socket = filepath.Join(tmp, "server.sock")
+	tp.Lock = filepath.Join(tmp, "server.lock")
+	tp.ServerLog = filepath.Join(tmp, "server.log")
+	tp.PluginLog = filepath.Join(tmp, "plugin.log")
+	if err := paths.Ensure(tp); err != nil {
+		t.Fatal(err)
+	}
+	fi, err := os.Stat(tmp)
+	if err != nil || fi.Mode().Perm() != 0700 {
+		t.Fatalf("root mode = %v, want 0700", fi)
+	}
+	for _, lf := range []string{tp.ServerLog, tp.PluginLog} {
+		fi, err := os.Stat(lf)
+		if err != nil || fi.Mode().Perm() != 0600 {
+			t.Fatalf("log %s mode = %v, want 0600", lf, fi)
+		}
+	}
+
+	// Config (0600) and workflow files (0644) via the atomic writer.
+	if err := config.SaveMachine(tp.Config, &config.Machine{TaskPlugin: "jira", RunnerPlugin: "orca", HarnessPlugin: "opencode"}); err != nil {
+		t.Fatal(err)
+	}
+	fi, _ = os.Stat(tp.Config)
+	if fi.Mode().Perm() != 0600 {
+		t.Fatalf("config mode = %o, want 0600", fi.Mode().Perm())
+	}
+	wfPath := filepath.Join(tp.Workflows, "basicFlow.yaml")
+	if err := config.WriteAtomic(wfPath, []byte("name: basicFlow\n"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	fi, _ = os.Stat(wfPath)
+	if fi.Mode().Perm() != 0644 {
+		t.Fatalf("workflow mode = %o, want 0644", fi.Mode().Perm())
+	}
+
+	// Database (state.db), socket (server.sock), and lock (server.lock) are
+	// mode 0600 and are created by their owning components: state.db by the
+	// engine (asserted in TestDatabaseFileIsOwnerOnly, internal/execution/
+	// goworkflows), server.sock by the server (asserted in
+	// TestSocketIsOwnerOnly, internal/server), and server.lock by the serve
+	// startup flock (section 5.5). This test pins the fixed paths and the
+	// config/log/workflow modes config owns.
+	_ = tp.Database
+	_ = tp.Lock
+	_ = tp.Socket
+}

package/internal/config/merge_test.go

@@ -0,0 +1,118 @@
+package config_test
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// 3.4: Merge behavior per specs/workflow-definition "Task config merge
+// behavior is deterministic": root -> repo -> workflow -> node precedence,
+// recursive map merge, later scalar/list replaces, omitted keys inherit,
+// explicit YAML null rejected.
+
+func TestMergePrecedenceRootToNode(t *testing.T) {
+	root := config.RawValues{"assignee": "root-bot", "severity": "low"}
+	repo := config.RawValues{"severity": "medium"}
+	wf := config.RawValues{"severity": "high"}
+	node := config.RawValues{"severity": "critical"}
+
+	got := config.Merge(root, repo, wf, node)
+	if got["severity"] != "critical" {
+		t.Fatalf("severity = %v, want node value critical", got["severity"])
+	}
+	if got["assignee"] != "root-bot" {
+		t.Fatalf("assignee = %v, want inherited root-bot", got["assignee"])
+	}
+}
+
+func TestMergeMapsRecursively(t *testing.T) {
+	root := config.RawValues{
+		"transitionTo": map[string]any{"parentStatus": "In Progress", "taskStatus": "To Do"},
+	}
+	node := config.RawValues{
+		"transitionTo": map[string]any{"taskStatus": "In Review"},
+	}
+	got := config.Merge(root, node)
+	tr, ok := got["transitionTo"].(map[string]any)
+	if !ok {
+		t.Fatalf("transitionTo not a map: %T", got["transitionTo"])
+	}
+	if tr["parentStatus"] != "In Progress" {
+		t.Fatalf("nested parentStatus = %v, want inherited In Progress", tr["parentStatus"])
+	}
+	if tr["taskStatus"] != "In Review" {
+		t.Fatalf("nested taskStatus = %v, want node override In Review", tr["taskStatus"])
+	}
+}
+
+func TestMergeListReplaces(t *testing.T) {
+	root := config.RawValues{"labels": []any{"a", "b"}}
+	wf := config.RawValues{"labels": []any{"c"}}
+	got := config.Merge(root, wf)
+	if !reflect.DeepEqual(got["labels"], []any{"c"}) {
+		t.Fatalf("labels = %v, want replacement [c] not append", got["labels"])
+	}
+}
+
+func TestMergeScalarReplaces(t *testing.T) {
+	root := config.RawValues{"retries": "1"}
+	node := config.RawValues{"retries": "3"}
+	got := config.Merge(root, node)
+	if got["retries"] != "3" {
+		t.Fatalf("retries = %v, want 3", got["retries"])
+	}
+}
+
+func TestMergeOmittedKeyInherits(t *testing.T) {
+	root := config.RawValues{"project": "PAY", "component": "api"}
+	repo := config.RawValues{"component": "web"}
+	got := config.Merge(root, repo)
+	if got["project"] != "PAY" {
+		t.Fatalf("project = %v, want inherited PAY", got["project"])
+	}
+	if got["component"] != "web" {
+		t.Fatalf("component = %v, want web", got["component"])
+	}
+}
+
+func TestMergeRejectsExplicitNull(t *testing.T) {
+	// Explicit YAML null must be rejected by the documented validation path,
+	// not silently merged or dropped. DecodeStrict is the strict decode the
+	// adapters use; a null value is not a valid scalar/map/list.
+	node := config.RawValues{"assignee": nil}
+	var dst struct {
+		Assignee string `yaml:"assignee"`
+	}
+	if err := config.DecodeStrict(node, &dst); err == nil {
+		t.Fatal("explicit YAML null accepted by DecodeStrict; null must be rejected")
+	}
+}
+
+func TestMergeNullLayerRejectedAtValidation(t *testing.T) {
+	// Machine config containing an explicit null fails loading.
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	yaml := "taskPlugin: jira\nrunnerPlugin: orca\nharnessPlugin: opencode\ntaskConfig:\n  assignee: null\n"
+	if err := os.WriteFile(path, []byte(yaml), 0600); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := config.LoadMachine(path); err == nil {
+		t.Fatal("machine config with explicit null loaded; null must be rejected")
+	}
+}
+
+func TestMergeDoesNotMutateInputs(t *testing.T) {
+	root := config.RawValues{"m": map[string]any{"a": "1"}}
+	node := config.RawValues{"m": map[string]any{"b": "2"}}
+	_ = config.Merge(root, node)
+	if len(root["m"].(map[string]any)) != 1 {
+		t.Fatalf("root input mutated: %v", root)
+	}
+	if len(node["m"].(map[string]any)) != 1 {
+		t.Fatalf("node input mutated: %v", node)
+	}
+}

package/internal/config/writeatomic.go

@@ -0,0 +1,36 @@
+package config
+
+import (
+	"fmt"
+	"io/fs"
+	"os"
+	"path/filepath"
+
+	"github.com/google/renameio/v2"
+)
+
+// WriteAtomic creates a temporary sibling, writes and syncs it, sets
+// permissions, renames it over the destination, and syncs the parent
+// directory.
+func WriteAtomic(path string, data []byte, mode fs.FileMode) error {
+	pf, err := renameio.NewPendingFile(path, renameio.WithStaticPermissions(mode.Perm()))
+	if err != nil {
+		return fmt.Errorf("create temp for %s: %w", path, err)
+	}
+	defer pf.Cleanup()
+	if _, err := pf.Write(data); err != nil {
+		return fmt.Errorf("write temp for %s: %w", path, err)
+	}
+	if err := pf.CloseAtomicallyReplace(); err != nil {
+		return fmt.Errorf("atomic replace %s: %w", path, err)
+	}
+	dir, err := os.Open(filepath.Dir(path))
+	if err != nil {
+		return fmt.Errorf("open parent dir of %s: %w", path, err)
+	}
+	defer dir.Close()
+	if err := dir.Sync(); err != nil {
+		return fmt.Errorf("sync parent dir of %s: %w", path, err)
+	}
+	return nil
+}

package/internal/config/writeatomic_test.go

@@ -0,0 +1,98 @@
+package config_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/rajpopat27/relay-flow/internal/config"
+)
+
+// 3.30: WriteAtomic per specs/workflow-repo-management "Config and
+// workflow writes are atomically replaced": sibling temp, write+fsync, set
+// mode, rename over destination, fsync parent directory.
+
+func TestWriteAtomicCreatesAndReplaces(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "workflow.yaml")
+
+	if err := config.WriteAtomic(path, []byte("v1"), 0644); err != nil {
+		t.Fatalf("WriteAtomic create failed: %v", err)
+	}
+	fi, _ := os.Stat(path)
+	if fi.Mode().Perm() != 0644 {
+		t.Fatalf("mode = %o, want 0644", fi.Mode().Perm())
+	}
+
+	if err := config.WriteAtomic(path, []byte("v2-longer-content"), 0644); err != nil {
+		t.Fatalf("WriteAtomic replace failed: %v", err)
+	}
+	got, _ := os.ReadFile(path)
+	if string(got) != "v2-longer-content" {
+		t.Fatalf("content = %q, want complete replacement", got)
+	}
+}
+
+func TestWriteAtomicSetsModeOnReplace(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "config.yaml")
+	if err := config.WriteAtomic(path, []byte("a"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	// Replace with a different mode; the rename must carry the new mode.
+	if err := config.WriteAtomic(path, []byte("b"), 0644); err != nil {
+		t.Fatal(err)
+	}
+	fi, _ := os.Stat(path)
+	if fi.Mode().Perm() != 0644 {
+		t.Fatalf("mode after replace = %o, want 0644", fi.Mode().Perm())
+	}
+}
+
+func TestWriteAtomicLeavesNoTempOnSuccess(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "f.yaml")
+	if err := config.WriteAtomic(path, []byte("x"), 0600); err != nil {
+		t.Fatal(err)
+	}
+	entries, _ := os.ReadDir(dir)
+	if len(entries) != 1 {
+		names := []string{}
+		for _, e := range entries {
+			names = append(names, e.Name())
+		}
+		t.Fatalf("leftover files after atomic write: %v", names)
+	}
+}
+
+func TestWriteAtomicFailureLeavesPriorFileUsable(t *testing.T) {
+	// A failed replacement leaves the previous complete file intact and
+	// readable. Make the destination's parent non-writable by its owner so
+	// the sibling temp file cannot be created; the existing destination is
+	// never touched. (Deterministic for a non-root owner, which the test
+	// environment is.)
+	dir := t.TempDir()
+	path := filepath.Join(dir, "workflow.yaml")
+	if err := config.WriteAtomic(path, []byte("good-v1"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := os.Chmod(dir, 0500); err != nil {
+		t.Fatal(err)
+	}
+	err := config.WriteAtomic(path, []byte("bad-v2-partial"), 0644)
+	if cerr := os.Chmod(dir, 0700); cerr != nil {
+		t.Fatalf("restore dir perms: %v", cerr)
+	}
+
+	if err == nil {
+		t.Fatal("WriteAtomic into a non-writable dir succeeded; want failure")
+	}
+	got, rerr := os.ReadFile(path)
+	if rerr != nil {
+		t.Fatalf("prior file unreadable after failed write: %v", rerr)
+	}
+	if string(got) != "good-v1" {
+		t.Fatalf("prior file = %q, want intact good-v1", got)
+	}
+}