devrites 5.14.4 → 6.0.1

package/engine/tests/meta_test.go

@@ -1,37 +0,0 @@
-package main_test
-
-// Cross-cutting assertion: release acquisition is the only engine network boundary.
-
-import (
-	"os/exec"
-	"strings"
-	"testing"
-)
-
-// TestNetworkImportsStayInReleaseBoundary keeps update networking isolated from
-// workspace state, policy, proof, and installation logic.
-func TestNetworkImportsStayInReleaseBoundary(t *testing.T) {
-	if _, err := exec.LookPath("go"); err != nil {
-		t.Skip("go toolchain unavailable")
-	}
-	out, err := exec.Command("go", "list", "-f",
-		"{{.ImportPath}} {{join .Imports \" \"}}",
-		"github.com/devrites/devrites/...").Output()
-	if err != nil {
-		t.Fatalf("go list: %v", err)
-	}
-	forbidden := map[string]bool{"net": true, "net/http": true, "net/rpc": true, "net/smtp": true}
-	allowed := map[string]bool{"github.com/devrites/devrites/internal/release": true}
-	for _, line := range strings.Split(strings.TrimSpace(string(out)), "\n") {
-		fields := strings.Fields(line)
-		if len(fields) == 0 {
-			continue
-		}
-		pkg, imports := fields[0], fields[1:]
-		for _, imp := range imports {
-			if forbidden[imp] && !allowed[pkg] {
-				t.Errorf("first-party package %s imports forbidden network package %q", pkg, imp)
-			}
-		}
-	}
-}

package/engine/tests/parity_closeout_test.go

@@ -1,105 +0,0 @@
-package main_test
-
-// Golden snapshot for the ported close-out command (lib.CloseOut).
-//
-// close-out MUTATES the tree: it moves .devrites/work/<slug> to
-// .devrites/archive/<slug> and, when it is the active slug, clears
-// .devrites/ACTIVE. Each case snapshots the command's stdout + exit code (stderr
-// is diagnostic, not contract) and then asserts the post-move filesystem shape
-// with plain Go checks.
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestParityCloseOut(t *testing.T) {
-	dirExists := func(path string) bool {
-		fi, err := os.Stat(path)
-		return err == nil && fi.IsDir()
-	}
-	gone := func(path string) bool {
-		_, err := os.Stat(path)
-		return os.IsNotExist(err)
-	}
-
-	// run executes close-out in gw and snapshots its stdout + exit code under the
-	// current subtest's golden.
-	run := func(t *testing.T, gw string, args ...string) {
-		t.Helper()
-		out, code := runArgv(t, gw, libEnv, "", binPath, append([]string{"state", "close"}, args...)...)
-		assertGolden(t, out, code)
-	}
-
-	t.Run("active_slug_cleared", func(t *testing.T) {
-		slug := "feat-x"
-		gw := t.TempDir()
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "spec.md"), "# spec\n")
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "state.md"), "| schema | 4 |\n")
-		writeFile(t, gw, ".devrites/ACTIVE", slug+"\n")
-
-		run(t, gw, slug)
-
-		// archive created, work/ source gone, ACTIVE truncated.
-		if !dirExists(filepath.Join(gw, ".devrites/archive", slug)) {
-			t.Error("archive dir not created")
-		}
-		if !gone(filepath.Join(gw, ".devrites/work", slug)) {
-			t.Error("source workspace not moved")
-		}
-		if b, err := os.ReadFile(filepath.Join(gw, ".devrites/ACTIVE")); err != nil {
-			t.Fatalf("reading ACTIVE: %v", err)
-		} else if len(b) != 0 {
-			t.Errorf("ACTIVE not cleared: %q", string(b))
-		}
-	})
-
-	t.Run("active_pointed_elsewhere", func(t *testing.T) {
-		slug := "feat-y"
-		other := "someone-else\n"
-		gw := t.TempDir()
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "spec.md"), "# spec\n")
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "state.md"), "| schema | 4 |\n")
-		writeFile(t, gw, ".devrites/ACTIVE", other)
-
-		run(t, gw, slug)
-
-		// The archive moved, but ACTIVE (pointed elsewhere) is left untouched.
-		if !dirExists(filepath.Join(gw, ".devrites/archive", slug)) {
-			t.Error("archive dir not created")
-		}
-		if b, err := os.ReadFile(filepath.Join(gw, ".devrites/ACTIVE")); err != nil {
-			t.Fatalf("reading ACTIVE: %v", err)
-		} else if string(b) != other {
-			t.Errorf("ACTIVE changed: %q", string(b))
-		}
-	})
-
-	t.Run("missing_workspace", func(t *testing.T) {
-		// No workspace seeded -> non-zero exit, empty stdout.
-		gw := t.TempDir()
-		run(t, gw, "ghost")
-	})
-
-	t.Run("archive_clobber", func(t *testing.T) {
-		slug := "feat-z"
-		gw := t.TempDir()
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "spec.md"), "# spec\n")
-		writeFile(t, gw, filepath.Join(".devrites/work", slug, "state.md"), "| schema | 4 |\n")
-		writeFile(t, gw, filepath.Join(".devrites/archive", slug, "old.md"), "old\n")
-
-		run(t, gw, slug)
-
-		// Refused: source stays in place, the pre-existing archive is not clobbered.
-		if !dirExists(filepath.Join(gw, ".devrites/work", slug)) {
-			t.Error("source workspace was moved despite clobber refusal")
-		}
-	})
-
-	t.Run("missing_slug", func(t *testing.T) {
-		// No slug arg -> non-zero exit.
-		gw := t.TempDir()
-		run(t, gw)
-	})
-}

package/engine/tests/parity_githelpers_test.go

@@ -1,41 +0,0 @@
-package main_test
-
-import (
-	"os/exec"
-	"testing"
-)
-
-// requireGit skips a parity case when git is unavailable (the git-backed gates
-// fail open / skip without it, so a parity assertion would be meaningless).
-func requireGit(t *testing.T) {
-	t.Helper()
-	if _, err := exec.LookPath("git"); err != nil {
-		t.Skip("git not available; skipping git-backed parity case")
-	}
-}
-
-// runGit runs a git subcommand in dir and fails the test on error.
-func runGit(t *testing.T, dir string, args ...string) {
-	t.Helper()
-	cmd := exec.Command("git", append([]string{"-C", dir}, args...)...)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		t.Fatalf("git %v: %v\n%s", args, err, out)
-	}
-}
-
-// initGitRepo initialises a fresh, self-contained git repo in dir (local identity
-// + no signing, so `commit` never depends on the host's global config).
-func initGitRepo(t *testing.T, dir string) {
-	t.Helper()
-	runGit(t, dir, "init", "-q")
-	runGit(t, dir, "config", "user.email", "test@example.com")
-	runGit(t, dir, "config", "user.name", "Test")
-	runGit(t, dir, "config", "commit.gpgsign", "false")
-}
-
-// gitCommitAll stages every change and commits it.
-func gitCommitAll(t *testing.T, dir, msg string) {
-	t.Helper()
-	runGit(t, dir, "add", "-A")
-	runGit(t, dir, "commit", "-q", "-m", msg)
-}

package/engine/tests/parity_resolve_test.go

@@ -1,136 +0,0 @@
-package main_test
-
-import (
-	"os"
-	"path/filepath"
-	"regexp"
-	"testing"
-)
-
-// Golden snapshots for resolve include its changes to questions.md and state.md.
-// Each case records stdout and the exit code. Mutating cases also record the
-// resulting file bytes. The two nondeterministic timestamp fields (answered_at
-// and the Log entry) are masked out before the file content is snapshotted so the
-// golden is deterministic across runs.
-var (
-	reAnsweredAt = regexp.MustCompile(`answered_at: \S+`)
-	reLogTS      = regexp.MustCompile(`(?m)^- \S+ build: resolved`)
-)
-
-func maskResolveTS(s string) string {
-	s = reAnsweredAt.ReplaceAllString(s, "answered_at: TS")
-	s = reLogTS.ReplaceAllString(s, "- TS build: resolved")
-	return s
-}
-
-const resolveQuestions = `## q-1 blocking
-status: open
-answered_at:
-answer:
-
-## q-2 advisory
-status: open
-answered_at:
-answer:
-`
-
-const resolveState = `- Status: awaiting_human
-- Next step: wait for q-1
-- Schema: 4
-
-## Awaiting human
-- qid: q-1
-
-## Log
-- 2024-01-01 spec: created
-`
-
-func TestParityResolve(t *testing.T) {
-	// setup writes fixtures under .devrites/work/feat and returns the
-	// workspace root.
-	setup := func(t *testing.T, questions, state string) (gwork string) {
-		t.Helper()
-		gwork = t.TempDir()
-		writeFile(t, gwork, filepath.Join(".devrites", "work", "feat", "questions.md"), questions)
-		writeFile(t, gwork, filepath.Join(".devrites", "work", "feat", "state.md"), state)
-		writeFile(t, gwork, filepath.Join(".devrites", "ACTIVE"), "feat\n")
-		return gwork
-	}
-	// run executes resolve in gwork and snapshots stdout and the exit code under the
-	// current subtest's golden.
-	run := func(t *testing.T, gwork string, args ...string) {
-		t.Helper()
-		out, code := runArgv(t, gwork, libRootEnv(gwork), "", binPath, append([]string{"state", "resolve"}, args...)...)
-		assertGolden(t, out, code)
-	}
-	// assertFileGolden snapshots the masked content of a mutated file under a
-	// per-file golden key (t.Name()+"/"+name).
-	assertFileGolden := func(t *testing.T, gwork, name string) {
-		t.Helper()
-		b, err := os.ReadFile(filepath.Join(gwork, ".devrites", "work", "feat", name))
-		if err != nil {
-			t.Fatalf("reading %s: %v", name, err)
-		}
-		assertGoldenKey(t, t.Name()+"/"+name, maskResolveTS(string(b)))
-	}
-
-	t.Run("answer", func(t *testing.T) {
-		gwork := setup(t, resolveQuestions, resolveState)
-		run(t, gwork, "q-1", "use JWT with 15m expiry")
-		assertFileGolden(t, gwork, "questions.md")
-		assertFileGolden(t, gwork, "state.md")
-	})
-
-	t.Run("drop", func(t *testing.T) {
-		gwork := setup(t, resolveQuestions, resolveState)
-		run(t, gwork, "--drop", "q-2", "out of scope")
-		assertFileGolden(t, gwork, "questions.md")
-		assertFileGolden(t, gwork, "state.md")
-	})
-
-	t.Run("not-found", func(t *testing.T) {
-		gwork := setup(t, resolveQuestions, resolveState)
-		run(t, gwork, "q-99", "nope") // exit 3
-	})
-
-	t.Run("not-open", func(t *testing.T) {
-		answered := `## q-1 blocking
-status: answered
-answered_at: 2024-01-01T00:00:00Z
-answer: prior
-`
-		gwork := setup(t, answered, resolveState)
-		run(t, gwork, "q-1", "again") // exit 4
-	})
-
-	t.Run("batch", func(t *testing.T) {
-		gwork := setup(t, resolveQuestions, resolveState)
-		writeFile(t, gwork, "batch.txt", "q-1: answer one\n--drop q-2: reason two\n")
-		run(t, gwork, "--batch", "batch.txt")
-		assertFileGolden(t, gwork, "questions.md")
-	})
-
-	t.Run("batch-unterminated", func(t *testing.T) {
-		// No trailing newline: a final line without a terminating newline is not
-		// applied (q-2 stays open), so the golden captures the truncated batch.
-		gwork := setup(t, resolveQuestions, resolveState)
-		writeFile(t, gwork, "batch.txt", "q-1: answer one\n--drop q-2: reason two") // no trailing \n
-		run(t, gwork, "--batch", "batch.txt")
-		assertFileGolden(t, gwork, "questions.md")
-	})
-
-	t.Run("missing-answer", func(t *testing.T) {
-		gwork := setup(t, resolveQuestions, resolveState)
-		run(t, gwork, "q-1") // no answer text -> exit 5
-	})
-
-	t.Run("no-workspace", func(t *testing.T) {
-		// A bare tree with no explicit root, ACTIVE, or questions.md exits 2.
-		// Pointing DEVRITES_ROOT at the nonexistent .devrites child would instead
-		// be an explicit unsafe-root refusal, which is a different contract.
-		gwork := t.TempDir()
-		out, code := runArgv(t, gwork, libEnv, "", binPath, "state", "resolve", "q-1", "x")
-		assertGolden(t, out, code)
-	})
-
-}

package/engine/tests/parity_test.go

@@ -1,86 +0,0 @@
-package main_test
-
-// Golden CLI harness: run `devrites-engine <args>` against a fixture and compare its
-// stdout and exit code to a recorded snapshot under testdata/golden. The snapshots
-// were captured from the commands once they were proven correct, so a later change
-// that alters observable behaviour fails here. Regenerate them deliberately with
-// UPDATE_GOLDEN=1 (e.g. `UPDATE_GOLDEN=1 go test ./...`).
-//
-// stderr is not captured because it is diagnostic rather than contractual. Only
-// stdout (the output the hook/command consumer reads) and the exit code are.
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/devrites/devrites/internal/testutil"
-)
-
-var libEnv = []string{"LC_ALL=C", "DEVRITES_ROOT="}
-
-func libRootEnv(work string) []string {
-	return []string{"LC_ALL=C", "DEVRITES_ROOT=" + filepath.Join(work, ".devrites")}
-}
-
-func writeFile(t *testing.T, workdir, rel, content string) {
-	t.Helper()
-	testutil.WriteFile(t, filepath.Join(workdir, rel), content)
-}
-
-// assertGolden compares a command's output to the golden file for the current
-// subtest name; assertGoldenKey does the same under an explicit key (for tests
-// that snapshot more than one artifact, e.g. stdout plus a rewritten file).
-func assertGolden(t *testing.T, stdout string, code int) {
-	t.Helper()
-	assertGoldenKey(t, t.Name(), fmt.Sprintf("exit %d\n%s", code, stdout))
-}
-
-func assertGoldenKey(t *testing.T, key, got string) {
-	t.Helper()
-	path := filepath.Join(engineRoot, "testdata", "golden", key+".golden")
-	if os.Getenv("UPDATE_GOLDEN") != "" {
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatal(err)
-		}
-		if err := os.WriteFile(path, []byte(got), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		return
-	}
-	want, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatalf("missing golden %s: regenerate with UPDATE_GOLDEN=1: %v", path, err)
-	}
-	wantText := strings.ReplaceAll(string(want), "\r\n", "\n")
-	if got != wantText {
-		t.Errorf("golden mismatch for %s\n got: %q\nwant: %q", key, got, wantText)
-	}
-}
-
-// runArgv runs one command in workdir with extra env, returning stdout and exit
-// code. A non-ExitError failure (e.g. binary not found) fails the test.
-func runArgv(t *testing.T, workdir string, env []string, stdin string, name string, args ...string) (stdout string, code int) {
-	t.Helper()
-	cmd := exec.Command(name, args...)
-	cmd.Dir = workdir
-	cmd.Env = append(os.Environ(), env...)
-	cmd.Stdin = strings.NewReader(stdin)
-	var out, errBuf bytes.Buffer
-	cmd.Stdout = &out
-	cmd.Stderr = &errBuf
-	err := cmd.Run()
-	if err != nil {
-		var ee *exec.ExitError
-		if !errors.As(err, &ee) {
-			t.Fatalf("running %s %v: %v", name, args, err)
-		}
-		code = ee.ExitCode()
-	}
-	return out.String(), code
-}