devrites 6.0.3 → 6.1.0

package/engine/internal/lib/claims_test.go

@@ -1,267 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-func claimTestRoot(t *testing.T) string {
-	t.Helper()
-	root := filepath.Join(t.TempDir(), ".devrites")
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	return root
-}
-
-func runClaim(t *testing.T, root string, args ...string) (int, string, string) {
-	t.Helper()
-	var out, errOut bytes.Buffer
-	code := RunClaim(root, args, &out, &errOut)
-	return code, out.String(), errOut.String()
-}
-
-func TestClaimAddAndList(t *testing.T) {
-	root := claimTestRoot(t)
-	code, out, errOut := runClaim(t, root, "add", "--session", "s1", "--reason", "slice work", "pkg/a.go", "pkg/b.go")
-	if code != 0 {
-		t.Fatalf("add: code=%d stderr=%s", code, errOut)
-	}
-	if !strings.Contains(out, "cl-") || !strings.Contains(out, "2 path(s)") {
-		t.Fatalf("add output missing claim id/paths: %q", out)
-	}
-	code, out, _ = runClaim(t, root, "list")
-	if code != 0 || !strings.Contains(out, "session=s1") || !strings.Contains(out, "pkg/a.go") {
-		t.Fatalf("list: code=%d out=%q", code, out)
-	}
-}
-
-func TestClaimConflictBlocks(t *testing.T) {
-	root := claimTestRoot(t)
-	if code, _, e := runClaim(t, root, "add", "--session", "s1", "pkg/a.go"); code != 0 {
-		t.Fatalf("first add: %d %s", code, e)
-	}
-	code, _, errOut := runClaim(t, root, "add", "--session", "s2", "pkg/a.go")
-	if code != 3 {
-		t.Fatalf("conflicting add should exit 3, got %d", code)
-	}
-	if !strings.Contains(errOut, "BLOCKED") || !strings.Contains(errOut, "s1") {
-		t.Fatalf("conflict output should name holder: %q", errOut)
-	}
-	// Same session re-claim is allowed.
-	if code, _, e := runClaim(t, root, "add", "--session", "s1", "pkg/a.go"); code != 0 {
-		t.Fatalf("same-session re-claim: %d %s", code, e)
-	}
-	// Disjoint path is fine for another session.
-	if code, _, e := runClaim(t, root, "add", "--session", "s2", "pkg/c.go"); code != 0 {
-		t.Fatalf("disjoint add: %d %s", code, e)
-	}
-}
-
-func TestClaimCheck(t *testing.T) {
-	root := claimTestRoot(t)
-	code, out, _ := runClaim(t, root, "check", "pkg/a.go")
-	if code != 0 || !strings.Contains(out, "free") {
-		t.Fatalf("check free: %d %q", code, out)
-	}
-	if code, _, e := runClaim(t, root, "add", "--session", "s1", "pkg/a.go"); code != 0 {
-		t.Fatalf("add: %d %s", code, e)
-	}
-	code, out, _ = runClaim(t, root, "check", "--session", "s2", "pkg/a.go", "pkg/z.go")
-	if code != 3 || !strings.Contains(out, "s1") {
-		t.Fatalf("check conflict: %d %q", code, out)
-	}
-	// Holder's own check is free.
-	code, out, _ = runClaim(t, root, "check", "--session", "s1", "pkg/a.go")
-	if code != 0 {
-		t.Fatalf("check own: %d %q", code, out)
-	}
-}
-
-func TestClaimRelease(t *testing.T) {
-	root := claimTestRoot(t)
-	code, out, _ := runClaim(t, root, "add", "--session", "s1", "pkg/a.go")
-	if code != 0 {
-		t.Fatalf("add: %d", code)
-	}
-	id := strings.Fields(out)[1]
-	// Wrong session cannot release.
-	if code, _, e := runClaim(t, root, "release", "--session", "s2", "--id", id); code != 2 {
-		t.Fatalf("release by wrong session: %d %s", code, e)
-	}
-	if code, _, e := runClaim(t, root, "release", "--session", "s1", "--id", id); code != 0 {
-		t.Fatalf("release: %d %s", code, e)
-	}
-	// Released claim no longer conflicts.
-	code, _, _ = runClaim(t, root, "check", "--session", "s2", "pkg/a.go")
-	if code != 0 {
-		t.Fatalf("check after release: %d", code)
-	}
-	// Double release is a usage error.
-	if code, _, _ := runClaim(t, root, "release", "--session", "s1", "--id", id); code != 2 {
-		t.Fatalf("double release: %d", code)
-	}
-	// Unknown id.
-	if code, _, _ := runClaim(t, root, "release", "--session", "s1", "--id", "cl-nope"); code != 2 {
-		t.Fatalf("unknown release: %d", code)
-	}
-}
-
-func TestClaimExpiry(t *testing.T) {
-	root := claimTestRoot(t)
-	path := filepath.Join(root, ClaimsFile)
-	old := claimRecord{
-		ID:        "cl-old",
-		Session:   "s1",
-		Paths:     []string{"pkg/a.go"},
-		ClaimedAt: time.Now().UTC().Add(-time.Hour).Format(time.RFC3339),
-		ExpiresAt: time.Now().UTC().Add(-time.Minute).Format(time.RFC3339),
-	}
-	line, _ := json.Marshal(old)
-	if err := os.WriteFile(path, append(line, '\n'), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	// Expired claims do not conflict and do not list by default.
-	code, _, errOut := runClaim(t, root, "add", "--session", "s2", "pkg/a.go")
-	if code != 0 {
-		t.Fatalf("add over expired: %d %s", code, errOut)
-	}
-	code, out, _ := runClaim(t, root, "list")
-	if code != 0 || strings.Contains(out, "cl-old") {
-		t.Fatalf("list should hide expired: %d %q", code, out)
-	}
-	code, out, _ = runClaim(t, root, "list", "--all")
-	if code != 0 || !strings.Contains(out, "cl-old") || !strings.Contains(out, "expired") {
-		t.Fatalf("list --all should show expired: %d %q", code, out)
-	}
-}
-
-func TestClaimRejectsBadInput(t *testing.T) {
-	root := claimTestRoot(t)
-	cases := [][]string{
-		{"add", "pkg/a.go"},                                 // no session
-		{"add", "--session", "s1"},                          // no paths
-		{"add", "--session", "s1", "/abs/path.go"},          // absolute
-		{"add", "--session", "s1", "../escape.go"},          // traversal
-		{"add", "--session", "s1", ".devrites/work/x/f.md"}, // control tree
-		{"add", "--session", "s1", "a.go", "a.go"},          // duplicate
-		{"add", "--session", "bad session!", "a.go"},        // bad session
-		{"add", "--session", "s1", "--ttl", "x", "a.go"},    // bad ttl
-	}
-	for _, c := range cases {
-		if code, _, _ := runClaim(t, root, c...); code != 2 {
-			t.Fatalf("args %v: expected exit 2, got %d", c, code)
-		}
-	}
-	// TTL clamps rather than fails.
-	code, _, _ := runClaim(t, root, "add", "--session", "s1", "--ttl", "0", "pkg/a.go")
-	if code != 0 {
-		t.Fatalf("ttl clamp low: %d", code)
-	}
-	code, _, _ = runClaim(t, root, "add", "--session", "s1", "--ttl", "9999", "pkg/b.go")
-	if code != 0 {
-		t.Fatalf("ttl clamp high: %d", code)
-	}
-}
-
-func TestClaimLedgerToleratesMalformedLines(t *testing.T) {
-	root := claimTestRoot(t)
-	path := filepath.Join(root, ClaimsFile)
-	if err := os.WriteFile(path, []byte("not json\n{\"id\":\"x\"}\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	code, out, _ := runClaim(t, root, "list")
-	if code != 0 || !strings.Contains(out, "unparsed") {
-		t.Fatalf("malformed ledger: %d %q", code, out)
-	}
-}
-
-func TestClaimCheckFailsClosedOnUnparsedLine(t *testing.T) {
-	root := claimTestRoot(t)
-	path := filepath.Join(root, ClaimsFile)
-	full, err := json.Marshal(&claimRecord{
-		ID: "cl-1", Session: "s-1", Paths: []string{"b.txt"},
-		ClaimedAt: "2026-01-01T00:00:00Z",
-		ExpiresAt: time.Now().Add(time.Hour).UTC().Format(time.RFC3339),
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	truncated := string(full[:len(full)-12]) + "\n"
-	if err := os.WriteFile(path, []byte(truncated), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	latest, order, bad, err := readClaims(path)
-	if err != nil || bad != 1 || len(liveClaims(latest, order, time.Now())) != 0 {
-		t.Fatalf("premise: want 1 unparsed line and no live claims, got bad=%d live=%d err=%v", bad, len(liveClaims(latest, order, time.Now())), err)
-	}
-	code, out, errOut := runClaim(t, root, "check", "--session", "s-2", "b.txt")
-	if code == 0 || !strings.Contains(out+errOut, "unparsed") {
-		t.Fatalf("check over unreadable ledger must fail closed: code=%d out=%q err=%q", code, out, errOut)
-	}
-	code, out, errOut = runClaim(t, root, "add", "--session", "s-2", "b.txt")
-	if code == 0 || !strings.Contains(out+errOut, "unparsed") {
-		t.Fatalf("add over unreadable ledger must fail closed: code=%d out=%q err=%q", code, out, errOut)
-	}
-}
-
-func TestClaimAddConcurrentOverlapOneWins(t *testing.T) {
-	root := claimTestRoot(t)
-	const n = 8
-	codes := make(chan int, n)
-	var wg sync.WaitGroup
-	for i := range n {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			var out, errOut bytes.Buffer
-			codes <- RunClaim(root, []string{"add", "--session", fmt.Sprintf("s%d", i), "pkg/a.go"}, &out, &errOut)
-		}()
-	}
-	wg.Wait()
-	close(codes)
-	wins := 0
-	for c := range codes {
-		if c == 0 {
-			wins++
-		}
-	}
-	if wins != 1 {
-		t.Fatalf("overlapping concurrent claims: %d succeeded, want exactly 1", wins)
-	}
-}
-
-func TestClaimAddRejectsOversizedRecord(t *testing.T) {
-	root := claimTestRoot(t)
-	ledger := filepath.Join(root, ClaimsFile)
-	reason := strings.Repeat("<", 190000)
-	code, _, errOut := runClaim(t, root, "add", "--session", "s1", "--reason", reason, "a.txt")
-	if code != 2 {
-		t.Fatalf("oversized add should exit 2, got %d stderr=%.200s", code, errOut)
-	}
-	if info, err := os.Stat(ledger); err == nil && info.Size() != 0 {
-		t.Fatalf("oversized add wrote %d bytes to the ledger", info.Size())
-	}
-	if code, _, e := runClaim(t, root, "list"); code != 0 {
-		t.Fatalf("list after refused add: %d %s", code, e)
-	}
-}
-
-func TestClaimReadNamesLedgerOnOversizedLine(t *testing.T) {
-	root := claimTestRoot(t)
-	ledger := filepath.Join(root, ClaimsFile)
-	if err := os.WriteFile(ledger, []byte(strings.Repeat("x", (1<<20)+10)+"\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	code, _, errOut := runClaim(t, root, "list")
-	if code != 2 || !strings.Contains(errOut, ledger) || !strings.Contains(errOut, "repair") {
-		t.Fatalf("list: code=%d stderr=%q", code, errOut)
-	}
-}

package/engine/internal/lib/closeout_test.go

@@ -1,266 +0,0 @@
-package lib
-
-import (
-	"bytes"
-	"io"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/devrites/devrites/internal/state"
-)
-
-func writeFile(t *testing.T, path, body string) {
-	t.Helper()
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-		t.Fatalf("mkdir %s: %v", path, err)
-	}
-	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
-		t.Fatalf("write %s: %v", path, err)
-	}
-}
-
-func runCloseOut(t *testing.T, root string, args ...string) (int, string) {
-	t.Helper()
-	stdout, stderr := &bytes.Buffer{}, &bytes.Buffer{}
-	code := CloseOut(root, args, stdout, stderr)
-	return code, stdout.String() + stderr.String()
-}
-
-func TestCloseOutRejectsRootOverrideArgument(t *testing.T) {
-	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 4\n")
-
-	code, out := runCloseOut(t, root, "feat", t.TempDir())
-	if code != 4 || !strings.Contains(out, "usage: devrites-engine state close <slug>") {
-		t.Fatalf("state close override = %d, want usage refusal\n%s", code, out)
-	}
-	if !isFile(filepath.Join(root, "work", "feat", "state.md")) {
-		t.Fatal("state close mutated the workspace after an extra root argument")
-	}
-}
-
-func TestCloseOutRejectsWorkspaceSymlinkEscape(t *testing.T) {
-	root := t.TempDir()
-	outside := t.TempDir()
-	if err := os.MkdirAll(filepath.Join(root, "work"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Symlink(outside, filepath.Join(root, "work", "feat")); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-	writeFile(t, filepath.Join(outside, "state.md"), "outside\n")
-
-	code, out := runCloseOut(t, root, "feat")
-	if code != 1 {
-		t.Fatalf("close-out = %d, want 1\n%s", code, out)
-	}
-	if !strings.Contains(out, "invalid workspace") {
-		t.Fatalf("missing workspace diagnostic:\n%s", out)
-	}
-	if !isFile(filepath.Join(outside, "state.md")) {
-		t.Fatal("close-out moved a workspace through an external symlink")
-	}
-}
-
-func TestCloseOutRejectsArchiveSymlinkEscape(t *testing.T) {
-	root := t.TempDir()
-	outside := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 4\n")
-	if err := os.Symlink(outside, filepath.Join(root, "archive")); err != nil {
-		t.Skipf("symlinks unavailable: %v", err)
-	}
-
-	code, out := runCloseOut(t, root, "feat")
-	if code != 1 {
-		t.Fatalf("close-out = %d, want 1\n%s", code, out)
-	}
-	if !strings.Contains(out, "invalid archive") {
-		t.Fatalf("missing archive diagnostic:\n%s", out)
-	}
-	if !isFile(filepath.Join(root, "work", "feat", "state.md")) {
-		t.Fatal("close-out moved the workspace through an external archive symlink")
-	}
-	if entries, err := os.ReadDir(outside); err != nil {
-		t.Fatal(err)
-	} else if len(entries) != 0 {
-		t.Fatalf("outside archive changed: %v", entries)
-	}
-}
-
-func TestCloseOutRollsBackArchiveWhenActiveCannotBeCleared(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission model differs on Windows")
-	}
-	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 4\n")
-	writeFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
-	if err := os.MkdirAll(filepath.Join(root, "archive"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.Chmod(root, 0o555); err != nil {
-		t.Fatal(err)
-	}
-	defer func() { _ = os.Chmod(root, 0o755) }()
-
-	code, out := runCloseOut(t, root, "feat")
-	if code != 1 {
-		t.Fatalf("close-out = %d, want 1\n%s", code, out)
-	}
-	if !strings.Contains(out, "archive move rolled back") {
-		t.Fatalf("missing rollback diagnostic:\n%s", out)
-	}
-	if !isFile(filepath.Join(root, "work", "feat", "state.md")) {
-		t.Fatal("workspace was not restored after ACTIVE clear failed")
-	}
-	if _, err := os.Lstat(filepath.Join(root, "archive", "feat")); !os.IsNotExist(err) {
-		t.Fatalf("archive remained after rollback: %v", err)
-	}
-	data, err := os.ReadFile(filepath.Join(root, "ACTIVE"))
-	if err != nil || string(data) != "feat\n" {
-		t.Fatalf("ACTIVE changed after rollback: %q, %v", data, err)
-	}
-}
-
-// TestCloseOutSerializesRenameBehindFeatureLock holds the per-feature lock in a
-// concurrent writer and requires close-out to wait for it. Without the lock the
-// rename lands while the writer is mid-save, and the writer's MkdirAll re-creates
-// work/<slug> after the workspace has been archived.
-//
-// The barrier is channel-based: `locked` proves the writer owns the lock before
-// close-out starts, and `release` hands the workspace back only after close-out
-// has stayed blocked for the bounded wait below. That wait never signals
-// success: success is proven by the archive carrying the writer's file and
-// work/<slug> being gone. It only bounds how long an unsynchronized rename may
-// take to appear, so a missing lock fails fast instead of hanging.
-func TestCloseOutSerializesRenameBehindFeatureLock(t *testing.T) {
-	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 4\n")
-	writeFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
-
-	// dispatch.json is what a concurrent `dispatch` mid-save writes; it is
-	// written the way saveDispatch writes it, MkdirAll included, so the
-	// resurrection path is exercised rather than simulated.
-	dispatchPath := filepath.Join(root, "work", "feat", "dispatch.json")
-	locked := make(chan struct{})
-	release := make(chan struct{})
-	wrote := make(chan error, 1)
-	writerDone := make(chan error, 1)
-	go func() {
-		writerDone <- state.WithFeatureLock(root, "feat", func() error {
-			close(locked)
-			<-release
-			// Still holding the lock, as dispatch does across its load-modify-save.
-			if err := os.MkdirAll(filepath.Dir(dispatchPath), 0o755); err != nil {
-				wrote <- err
-				return err
-			}
-			wrote <- state.AtomicWrite(dispatchPath, []byte(`{"phase":"start"}`), 0o600)
-			return nil
-		})
-	}()
-	<-locked
-
-	closeDone := make(chan int, 1)
-	go func() { closeDone <- CloseOut(root, []string{"feat"}, io.Discard, io.Discard) }()
-
-	select {
-	case code := <-closeDone:
-		t.Fatalf("state close returned %d while an in-process writer held %s: "+
-			"the rename is not serialized behind the feature lock, so a concurrent "+
-			"writer can re-create work/feat after the workspace has been archived",
-			code, filepath.Join("work", "feat", ".lock"))
-	case <-time.After(750 * time.Millisecond):
-		// Still blocked on the lock: correct.
-	}
-
-	// Release the writer only once close-out is demonstrably parked, then let the
-	// writer's save land. With the lock held across the rename, the rename cannot
-	// have happened yet, so this file is archived rather than left behind.
-	close(release)
-	if err := <-wrote; err != nil {
-		t.Fatalf("concurrent dispatch save: %v", err)
-	}
-	if err := <-writerDone; err != nil {
-		t.Fatalf("concurrent writer lock: %v", err)
-	}
-
-	var code int
-	select {
-	case code = <-closeDone:
-	case <-time.After(10 * time.Second):
-		t.Fatal("state close did not finish after the feature lock was released")
-	}
-	if code != 0 {
-		t.Fatalf("state close = %d, want 0 after the concurrent writer released the lock\n", code)
-	}
-	if !isFile(filepath.Join(root, "archive", "feat", "dispatch.json")) {
-		t.Fatal("concurrent dispatch.json was not archived: the rename did not run after the writer's save")
-	}
-	if _, err := os.Lstat(filepath.Join(root, "work", "feat")); !os.IsNotExist(err) {
-		t.Fatalf("work/feat was re-created by the concurrent writer after close-out: %v", err)
-	}
-	if data, err := os.ReadFile(filepath.Join(root, "ACTIVE")); err != nil || len(data) != 0 {
-		t.Fatalf("ACTIVE = %q (%v), want cleared", data, err)
-	}
-}
-
-// TestCloseOutReleasesFeatureLockBeforeRenameWhenPlatformRequires injects the
-// Windows decision and checks, from inside the rename, that the feature lock is
-// free: another locker acquires it while the workspace still exists. With the
-// lock still held at the rename that locker stays blocked.
-func TestCloseOutReleasesFeatureLockBeforeRenameWhenPlatformRequires(t *testing.T) {
-	root := t.TempDir()
-	writeFile(t, filepath.Join(root, "work", "feat", "state.md"), "inside\n- Schema: 4\n")
-	writeFile(t, filepath.Join(root, "ACTIVE"), "feat\n")
-
-	origRelease, origRename := releaseLockBeforeRename, renameWorkspace
-	t.Cleanup(func() { releaseLockBeforeRename, renameWorkspace = origRelease, origRename })
-	releaseLockBeforeRename = true
-
-	var lockFreeAtRename bool
-	renameWorkspace = func(from, to string) error {
-		acquired := make(chan struct{})
-		done := make(chan error, 1)
-		go func() {
-			done <- state.WithFeatureLock(root, "feat", func() error {
-				close(acquired)
-				return nil
-			})
-		}()
-		select {
-		case <-acquired:
-			lockFreeAtRename = true
-			<-done
-		case <-time.After(750 * time.Millisecond):
-			// Still blocked: the rename is about to run with the lock held.
-			// The locker is drained after CloseOut returns.
-			t.Cleanup(func() { <-done })
-		}
-		return os.Rename(from, to)
-	}
-
-	code, out := runCloseOut(t, root, "feat")
-	if code != 0 {
-		t.Fatalf("state close = %d, want 0\n%s", code, out)
-	}
-	if !lockFreeAtRename {
-		t.Fatal("the feature lock was still held when the workspace was renamed")
-	}
-	if !isFile(filepath.Join(root, "archive", "feat", "state.md")) {
-		t.Fatal("workspace was not archived")
-	}
-}
-
-func TestCloseOutMissingWorkspaceNamesResolvedPath(t *testing.T) {
-	root := t.TempDir()
-
-	code, out := runCloseOut(t, root, "ghost")
-	want := filepath.Join(root, "work", "ghost")
-	if code != 4 || !strings.Contains(out, "ghost") || !strings.Contains(out, want) {
-		t.Fatalf("state close missing workspace = %d, want exit 4 naming %q\n%s", code, want, out)
-	}
-}