A retry after any attempt that did not commit failed with
worktree prepare failed: checkout branch <branch>:
a branch named "refs/heads/<branch>" already exists
on a branch that was never the problem. refresh inferred "the branch does
not exist yet" from a failed checkout and reported whatever the Create
fallback then returned, so the real failure was replaced by a false one --
and the operator had no way to tell that the park reason was fiction.
The real failure, reproduced: a stage running in the container can leave a
path whose TYPE contradicts the tree refresh resets onto -- a directory
where the base tree has a file, or a file where the base tree has a
directory. go-git's hard reset cannot write over that contradiction and
fails with `openat <path>: is a directory` / `not a directory`, which is
exactly the failure the Create fallback then relabelled. Retry could not
recover from it, and a second path of the same class (a branch removed
while HEAD still pointed at it) failed with "reference not found".
refresh now clears the worktree against the tree it is resetting ONTO
before it checks anything out, which removes exactly those conflicts -- an
on-disk directory the tree declares as a file is untracked, and so is a
file the tree declares as a directory -- and resolves the branch's
existence from the reference store instead of inferring it. Resume gets the
same treatment, so the remediate path cannot fail the same way.
This is the third fix to this function (Force in 37792c9e was the second),
so the checkout/reset/clean sequence is rewritten rather than patched again.
1130 lines
39 KiB
Go
1130 lines
39 KiB
Go
package worktree
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/go-git/go-git/v6"
|
|
gitconfig "github.com/go-git/go-git/v6/config"
|
|
"github.com/go-git/go-git/v6/plumbing"
|
|
"github.com/go-git/go-git/v6/plumbing/filemode"
|
|
"github.com/go-git/go-git/v6/plumbing/object"
|
|
|
|
"github.com/samcharles93/archie-core/internal/container"
|
|
)
|
|
|
|
const testBase = "main"
|
|
|
|
func testSignature() *object.Signature {
|
|
return &object.Signature{
|
|
Name: "seeder",
|
|
Email: "seed@example.com",
|
|
When: time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC),
|
|
}
|
|
}
|
|
|
|
// newLocalRemote creates a bare repo with one commit on main and returns
|
|
// the directory that serves as the fake forge host: the bare repo lives
|
|
// at <host>/<owner>/<repo>.git so cloneURL resolves it.
|
|
//
|
|
// Built with go-git rather than by shelling out, so the suite no longer
|
|
// requires a git binary on the machine running it.
|
|
func newLocalRemote(t *testing.T, owner, repo string) string {
|
|
t.Helper()
|
|
host := t.TempDir()
|
|
bare := filepath.Join(host, owner, repo+".git")
|
|
|
|
if _, err := git.PlainInit(bare, true, git.WithDefaultBranch(
|
|
plumbing.NewBranchReferenceName(testBase),
|
|
)); err != nil {
|
|
t.Fatalf("init bare remote: %v", err)
|
|
}
|
|
|
|
seed := filepath.Join(t.TempDir(), "seed")
|
|
sr, err := git.PlainInit(seed, false, git.WithDefaultBranch(
|
|
plumbing.NewBranchReferenceName(testBase),
|
|
))
|
|
if err != nil {
|
|
t.Fatalf("init seed repo: %v", err)
|
|
}
|
|
writeSeedCommit(t, sr, seed, "README.md", "seed\n", "seed")
|
|
|
|
if _, err := sr.CreateRemote(&gitconfig.RemoteConfig{
|
|
Name: git.DefaultRemoteName,
|
|
URLs: []string{bare},
|
|
}); err != nil {
|
|
t.Fatalf("add remote: %v", err)
|
|
}
|
|
ref := plumbing.NewBranchReferenceName(testBase)
|
|
if err := sr.Push(&git.PushOptions{
|
|
RemoteName: git.DefaultRemoteName,
|
|
RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec(ref + ":" + ref)},
|
|
}); err != nil {
|
|
t.Fatalf("seed push: %v", err)
|
|
}
|
|
return host
|
|
}
|
|
|
|
func writeSeedCommit(t *testing.T, r *git.Repository, dir, name, content, message string) plumbing.Hash {
|
|
t.Helper()
|
|
if err := os.WriteFile(filepath.Join(dir, name), []byte(content), 0o600); err != nil {
|
|
t.Fatalf("write %s: %v", name, err)
|
|
}
|
|
disableSigning(t, r)
|
|
wt, err := r.Worktree()
|
|
if err != nil {
|
|
t.Fatalf("worktree: %v", err)
|
|
}
|
|
if _, err := wt.Add(name); err != nil {
|
|
t.Fatalf("add %s: %v", name, err)
|
|
}
|
|
sig := testSignature()
|
|
hash, err := wt.Commit(message, &git.CommitOptions{Author: sig, Committer: sig})
|
|
if err != nil {
|
|
t.Fatalf("commit: %v", err)
|
|
}
|
|
return hash
|
|
}
|
|
|
|
// disableSigning mirrors what Manager.setIdentity does for real clones,
|
|
// so fixtures do not inherit commit.gpgSign from the host's global config.
|
|
func disableSigning(t *testing.T, r *git.Repository) {
|
|
t.Helper()
|
|
cfg, err := r.Config()
|
|
if err != nil {
|
|
t.Fatalf("read fixture config: %v", err)
|
|
}
|
|
cfg.Raw.Section("commit").SetOption("gpgsign", "false")
|
|
if err := r.SetConfig(cfg); err != nil {
|
|
t.Fatalf("write fixture config: %v", err)
|
|
}
|
|
}
|
|
|
|
func newManager(t *testing.T, host string) *Manager {
|
|
t.Helper()
|
|
return &Manager{
|
|
WorkDir: t.TempDir(),
|
|
BotUser: "archie-bot",
|
|
BotEmail: "archie@example.com",
|
|
BaseURL: host,
|
|
}
|
|
}
|
|
|
|
func TestPrepareCommitPushRoundTrip(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, branch, err := m.Prepare(ctx, "acme", "todo", testBase, 7, "feat: add widget", "", "feature")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if !strings.HasPrefix(branch, "feat/7-") {
|
|
t.Errorf("branch = %q, want prefix feat/7-", branch)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, preparedSentinel)); err != nil {
|
|
t.Errorf("prepared sentinel missing: %v", err)
|
|
}
|
|
|
|
// A clean tree must report "nothing committed" rather than erroring.
|
|
committed, err := m.CommitAll(ctx, dir, "no-op")
|
|
if err != nil {
|
|
t.Fatalf("CommitAll() on clean tree error = %v", err)
|
|
}
|
|
if committed {
|
|
t.Error("CommitAll() = true on a clean tree, want false")
|
|
}
|
|
|
|
if err := os.WriteFile(filepath.Join(dir, "widget.txt"), []byte("one\ntwo\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
committed, err = m.CommitAll(ctx, dir, "feat: add widget")
|
|
if err != nil {
|
|
t.Fatalf("CommitAll() error = %v", err)
|
|
}
|
|
if !committed {
|
|
t.Fatal("CommitAll() = false, want true after adding a file")
|
|
}
|
|
|
|
files, err := m.ChangedFiles(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("ChangedFiles() error = %v", err)
|
|
}
|
|
if len(files) != 1 || files[0] != "widget.txt" {
|
|
t.Errorf("ChangedFiles() = %v, want [widget.txt]", files)
|
|
}
|
|
|
|
lines, err := m.ChangedLines(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("ChangedLines() error = %v", err)
|
|
}
|
|
if lines != 2 {
|
|
t.Errorf("ChangedLines() = %d, want 2", lines)
|
|
}
|
|
|
|
diff, err := m.Diff(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("Diff() error = %v", err)
|
|
}
|
|
if !strings.Contains(diff, "widget.txt") {
|
|
t.Errorf("Diff() does not mention the changed file:\n%s", diff)
|
|
}
|
|
|
|
if err := m.Push(ctx, dir, branch); err != nil {
|
|
t.Fatalf("Push() error = %v", err)
|
|
}
|
|
// The branch must actually exist on the remote afterwards.
|
|
bare := filepath.Join(host, "acme", "todo.git")
|
|
remote, err := git.PlainOpen(bare)
|
|
if err != nil {
|
|
t.Fatalf("open bare remote: %v", err)
|
|
}
|
|
if _, err := remote.Reference(plumbing.NewBranchReferenceName(branch), true); err != nil {
|
|
t.Errorf("branch %q not present on remote after Push: %v", branch, err)
|
|
}
|
|
}
|
|
|
|
func TestPrepareIsIdempotent(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir1, branch1, err := m.Prepare(ctx, "acme", "todo", testBase, 3, "fix: thing", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("first Prepare() error = %v", err)
|
|
}
|
|
// A marker file proves the second call reused the clone instead of
|
|
// wiping and re-cloning it.
|
|
marker := filepath.Join(dir1, ".git", "reuse-marker")
|
|
if err := os.WriteFile(marker, nil, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
dir2, branch2, err := m.Prepare(ctx, "acme", "todo", testBase, 3, "fix: thing", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("second Prepare() error = %v", err)
|
|
}
|
|
if dir1 != dir2 || branch1 != branch2 {
|
|
t.Errorf("Prepare() not stable: (%q,%q) then (%q,%q)", dir1, branch1, dir2, branch2)
|
|
}
|
|
if _, err := os.Stat(marker); err != nil {
|
|
t.Error("second Prepare() re-cloned instead of reusing the prepared worktree")
|
|
}
|
|
}
|
|
|
|
// TestPrepareRecoversFromADirtyWorktreeOnRetry reproduces a real retry
|
|
// failure seen in production: a task that got interrupted mid-stage (killed
|
|
// container, or a stage that edits files before ever reaching commit)
|
|
// leaves uncommitted local changes -- a modified tracked file plus an
|
|
// untracked one -- sitting in the worktree. HEAD is already on the correct
|
|
// branch (this is not the "no sentinel" case above). refresh's checkout,
|
|
// without Force, resets in git's MergeReset mode, which can fail to
|
|
// reconcile a working tree that differs from HEAD even when the target
|
|
// commit hasn't moved -- and did fail here with
|
|
// `checkout branch <branch>: a branch named "refs/heads/<branch>" already
|
|
// exists`, since the fallback that mis-assumes "checkout failed means the
|
|
// branch doesn't exist yet" then collides with the branch that, in fact,
|
|
// already exists. Retry must recover from this on its own; a worktree that
|
|
// refresh is about to hard-reset to base has no reason to fail here at all.
|
|
func TestPrepareRecoversFromADirtyWorktreeOnRetry(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
seedDir := filepath.Join(t.TempDir(), "ignore-seed")
|
|
seedRepo, err := git.PlainClone(seedDir, &git.CloneOptions{URL: filepath.Join(host, "acme", "todo.git")})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
writeSeedCommit(t, seedRepo, seedDir, ".gitignore", "bin/\n", "chore: ignore build output")
|
|
if err := os.Symlink("README.md", filepath.Join(seedDir, "readme-link")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
seedWorktree, err := seedRepo.Worktree()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := seedWorktree.Add("readme-link"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sig := testSignature()
|
|
if _, err := seedWorktree.Commit("chore: add tracked symlink", &git.CommitOptions{Author: sig, Committer: sig}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
baseRef := plumbing.NewBranchReferenceName(testBase)
|
|
if err := seedRepo.Push(&git.PushOptions{RemoteName: git.DefaultRemoteName, RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec(baseRef + ":" + baseRef)}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m := newManager(t, host)
|
|
|
|
dir, branch, err := m.Prepare(ctx, "acme", "todo", testBase, 9, "fix: retry robustness", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("first Prepare() error = %v", err)
|
|
}
|
|
|
|
// Simulate an interrupted attempt: a tracked file edited but never
|
|
// committed, plus a new file the agent created and never added.
|
|
if err := os.WriteFile(filepath.Join(dir, "README.md"), []byte("seed\nedited, uncommitted\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "scratch.txt"), []byte("uncommitted new file\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(dir, "bin"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "bin", "stale"), []byte("ignored output\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
dir2, branch2, err := m.Prepare(ctx, "acme", "todo", testBase, 9, "fix: retry robustness", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("retry Prepare() on a dirty worktree error = %v, want recovery", err)
|
|
}
|
|
if dir2 != dir || branch2 != branch {
|
|
t.Errorf("retry Prepare() = (%q, %q), want the same (%q, %q)", dir2, branch2, dir, branch)
|
|
}
|
|
|
|
// Retry starts from the base commit: neither tracked edits nor untracked
|
|
// output abandoned by the previous attempt may survive into the commit
|
|
// that CommitAll will publish for this attempt.
|
|
content, err := os.ReadFile(filepath.Join(dir, "README.md"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(content) != "seed\n" {
|
|
t.Errorf("README.md = %q, want the base commit's content restored", content)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "scratch.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("abandoned untracked file survived retry: %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, "bin", "stale")); !os.IsNotExist(err) {
|
|
t.Fatalf("ignored abandoned file survived retry: %v", err)
|
|
}
|
|
if target, err := os.Readlink(filepath.Join(dir, "readme-link")); err != nil || target != "README.md" {
|
|
t.Fatalf("tracked symlink = (%q, %v), want README.md", target, err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, preparedSentinel)); err != nil {
|
|
t.Fatalf("retry removed prepared sentinel: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "intended.txt"), []byte("new attempt\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if changed, err := m.CommitAll(ctx, dir, "feat: intended retry change"); err != nil || !changed {
|
|
t.Fatalf("CommitAll() = (%v, %v), want a commit", changed, err)
|
|
}
|
|
files, err := m.ChangedFiles(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(files) != 1 || files[0] != "intended.txt" {
|
|
t.Fatalf("ChangedFiles() = %v, want only intended.txt", files)
|
|
}
|
|
}
|
|
|
|
// TestPrepareRecoversFromAPathTypeConflictOnRetry covers the retry failure
|
|
// that followed the dirty-worktree one above, and the first that was not
|
|
// about the *contents* of a file. A stage running inside the container can
|
|
// leave a path whose TYPE contradicts the tree refresh resets onto: a
|
|
// directory where the base tree has a file, or a file where the base tree
|
|
// has a directory. go-git's hard reset cannot write over that contradiction --
|
|
// it fails with `openat <path>: is a directory` / `not a directory` -- and the
|
|
// Create-fallback in refresh then reported the whole thing as
|
|
// `checkout branch <branch>: a branch named "refs/heads/<branch>" already
|
|
// exists`. That names a branch that was never the problem, and it is the
|
|
// reason a retry could not recover: the reported obstacle was not the real
|
|
// one.
|
|
//
|
|
// refresh's contract is to discard the working tree, so a path it cannot
|
|
// reset over is a path it has to clear first.
|
|
func TestPrepareRecoversFromAPathTypeConflictOnRetry(t *testing.T) {
|
|
cases := []struct {
|
|
name string
|
|
wreck func(t *testing.T, dir string)
|
|
}{
|
|
{"directory where the tree has a file", func(t *testing.T, dir string) {
|
|
if err := os.Remove(filepath.Join(dir, "README.md")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(dir, "README.md", "inner"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "README.md", "inner", "junk"), []byte("junk\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{"file where the tree has a directory", func(t *testing.T, dir string) {
|
|
if err := os.RemoveAll(filepath.Join(dir, "pkg")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "pkg"), []byte("now a file\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{"directory where the tree has a nested file", func(t *testing.T, dir string) {
|
|
if err := os.RemoveAll(filepath.Join(dir, "pkg")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(dir, "pkg", "a.txt"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "pkg", "a.txt", "junk"), []byte("junk\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
}
|
|
|
|
for _, c := range cases {
|
|
t.Run(c.name, func(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
seedTrackedPath(t, host, "pkg/a.txt", "a\n")
|
|
m := newManager(t, host)
|
|
|
|
dir, branch, err := m.Prepare(ctx, "acme", "todo", testBase, 21, "fix: path type conflict", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("first Prepare() error = %v", err)
|
|
}
|
|
c.wreck(t, dir)
|
|
|
|
dir2, branch2, err := m.Prepare(ctx, "acme", "todo", testBase, 21, "fix: path type conflict", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("retry Prepare() over a path type conflict error = %v, want recovery", err)
|
|
}
|
|
if dir2 != dir || branch2 != branch {
|
|
t.Errorf("retry Prepare() = (%q, %q), want the same (%q, %q)", dir2, branch2, dir, branch)
|
|
}
|
|
|
|
// The retry must leave the base tree's own shape behind, not the
|
|
// wreckage: whichever type the previous attempt left, the tracked
|
|
// path has to come back as the tree declares it.
|
|
info, err := os.Lstat(filepath.Join(dir, "README.md"))
|
|
if err != nil {
|
|
t.Fatalf("README.md after retry: %v", err)
|
|
}
|
|
if info.IsDir() {
|
|
t.Error("README.md is still a directory, want the base tree's regular file")
|
|
}
|
|
content, err := os.ReadFile(filepath.Join(dir, "README.md"))
|
|
if err != nil {
|
|
t.Fatalf("read README.md after retry: %v", err)
|
|
}
|
|
if string(content) != "seed\n" {
|
|
t.Errorf("README.md = %q, want the base commit's content restored", content)
|
|
}
|
|
if pkg, err := os.Stat(filepath.Join(dir, "pkg")); err != nil {
|
|
t.Fatalf("pkg after retry: %v", err)
|
|
} else if !pkg.IsDir() {
|
|
t.Error("pkg is still a file, want the base tree's directory")
|
|
}
|
|
if a, err := os.ReadFile(filepath.Join(dir, "pkg", "a.txt")); err != nil {
|
|
t.Fatalf("read pkg/a.txt after retry: %v", err)
|
|
} else if string(a) != "a\n" {
|
|
t.Errorf("pkg/a.txt = %q, want the base commit's content restored", a)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestPrepareCreatesTheBranchWhenItIsGenuinelyMissing keeps the other half of
|
|
// refresh's branch handling honest: resolving a branch's existence before
|
|
// deciding whether to create it must not lose the create path. The branch name
|
|
// derives from the issue title, so an edited title between attempts renames the
|
|
// branch, and the second attempt has to create it.
|
|
func TestPrepareCreatesTheBranchWhenItIsGenuinelyMissing(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 22, "fix: first title", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("first Prepare() error = %v", err)
|
|
}
|
|
r, err := git.PlainOpen(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
first := archieBranch(22, "fix: first title", "bug")
|
|
if err := r.Storer.RemoveReference(plumbing.NewBranchReferenceName(first)); err != nil {
|
|
t.Fatalf("remove branch %s: %v", first, err)
|
|
}
|
|
|
|
_, branch, err := m.Prepare(ctx, "acme", "todo", testBase, 22, "fix: renamed title", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() after the branch was removed error = %v, want it created", err)
|
|
}
|
|
if _, err := r.Reference(plumbing.NewBranchReferenceName(branch), false); err != nil {
|
|
t.Errorf("branch %q not present after Prepare(): %v", branch, err)
|
|
}
|
|
}
|
|
|
|
// seedTrackedPath commits one path (creating its parent directories) onto the
|
|
// fake remote's base branch, so a fixture can have a tracked *directory* as
|
|
// well as the single tracked file newLocalRemote seeds.
|
|
func seedTrackedPath(t *testing.T, host, path, content string) {
|
|
t.Helper()
|
|
seedDir := filepath.Join(t.TempDir(), "path-seed")
|
|
r, err := git.PlainClone(seedDir, &git.CloneOptions{URL: filepath.Join(host, "acme", "todo.git")})
|
|
if err != nil {
|
|
t.Fatalf("clone path seed: %v", err)
|
|
}
|
|
full := filepath.Join(seedDir, filepath.FromSlash(path))
|
|
if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(full, []byte(content), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
disableSigning(t, r)
|
|
wt, err := r.Worktree()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := wt.Add(path); err != nil {
|
|
t.Fatalf("add %s: %v", path, err)
|
|
}
|
|
sig := testSignature()
|
|
if _, err := wt.Commit("chore: seed "+path, &git.CommitOptions{Author: sig, Committer: sig}); err != nil {
|
|
t.Fatalf("commit %s: %v", path, err)
|
|
}
|
|
if err := r.Push(&git.PushOptions{RemoteName: git.DefaultRemoteName}); err != nil {
|
|
t.Fatalf("push %s: %v", path, err)
|
|
}
|
|
}
|
|
|
|
// A repository whose .git is a gitdir *file* rather than a directory (a
|
|
// linked worktree, or a clone adopted by migrateLegacy) must still have its
|
|
// abandoned untracked files cleaned. Returning filepath.SkipDir for a
|
|
// non-directory aborts the remaining entries of its parent -- at the
|
|
// worktree root that is the entire walk, so cleaning silently did nothing
|
|
// and CommitAll published the leftovers on the next attempt.
|
|
func TestCleanUntrackedHandlesGitdirFile(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 12, "fix: gitdir file", "", "bug")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
|
|
// Relocate the repository metadata and leave a gitdir pointer behind.
|
|
gitDir := filepath.Join(t.TempDir(), "detached-gitdir")
|
|
if err := os.Rename(filepath.Join(dir, ".git"), gitDir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, ".git"), []byte("gitdir: "+gitDir+"\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Sorts after ".git", so it is only reached if the walk continues.
|
|
abandoned := filepath.Join(dir, "scratch.txt")
|
|
if err := os.WriteFile(abandoned, []byte("abandoned\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
r, err := git.PlainOpen(dir)
|
|
if err != nil {
|
|
t.Fatalf("PlainOpen() with a gitdir file error = %v", err)
|
|
}
|
|
head, err := r.Head()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
headCommit, err := r.CommitObject(head.Hash())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
headTree, err := headCommit.Tree()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := cleanUntracked(dir, headTree); err != nil {
|
|
t.Fatalf("cleanUntracked() error = %v", err)
|
|
}
|
|
if _, err := os.Stat(abandoned); !os.IsNotExist(err) {
|
|
t.Errorf("abandoned untracked file survived cleaning: %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, ".git")); err != nil {
|
|
t.Errorf("gitdir pointer file was removed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCollectTrackedPathsClassifiesGitEntries(t *testing.T) {
|
|
files := make(map[string]struct{})
|
|
dirs := make(map[string]struct{})
|
|
opaque := make(map[string]struct{})
|
|
tree := &object.Tree{Entries: []object.TreeEntry{
|
|
{Name: "file", Mode: filemode.Regular},
|
|
{Name: "link", Mode: filemode.Symlink},
|
|
{Name: "dependency", Mode: filemode.Submodule},
|
|
}}
|
|
if err := collectTrackedPaths(tree, "", files, dirs, opaque); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, name := range []string{"file", "link"} {
|
|
if _, ok := files[name]; !ok {
|
|
t.Errorf("tracked file %q was not classified", name)
|
|
}
|
|
}
|
|
if _, ok := opaque["dependency"]; !ok {
|
|
t.Error("submodule was not classified as an opaque directory")
|
|
}
|
|
}
|
|
|
|
// An interrupted clone leaves a directory with no sentinel. Prepare must
|
|
// discard it rather than trying to reuse a half-built worktree.
|
|
func TestPrepareDiscardsDirectoryWithoutSentinel(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir := m.Dir("acme", "todo", 11)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
junk := filepath.Join(dir, "half-written")
|
|
if err := os.WriteFile(junk, []byte("partial"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, _, err := m.Prepare(ctx, "acme", "todo", testBase, 11, "chore: retry", "", "chore"); err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if _, err := os.Stat(junk); !os.IsNotExist(err) {
|
|
t.Error("Prepare() reused an interrupted clone instead of discarding it")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, preparedSentinel)); err != nil {
|
|
t.Errorf("prepared sentinel missing after recovery: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPrepareErrors(t *testing.T) {
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
|
|
tests := []struct {
|
|
name string
|
|
owner string
|
|
repo string
|
|
base string
|
|
host string
|
|
}{
|
|
{name: "unknown base branch", owner: "acme", repo: "todo", base: "no-such-branch", host: host},
|
|
{name: "unknown repository", owner: "acme", repo: "missing", base: testBase, host: host},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
m := newManager(t, tc.host)
|
|
_, _, err := m.Prepare(context.Background(), tc.owner, tc.repo, tc.base, 1, "t", "", "")
|
|
if err == nil {
|
|
t.Fatal("Prepare() error = nil, want a failure")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPrepareRefreshRejectsUnknownBase(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
if _, _, err := m.Prepare(ctx, "acme", "todo", testBase, 12, "fix: base", "", "bug"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, _, err := m.Prepare(ctx, "acme", "todo", "missing-base", 12, "fix: base", "", "bug"); err == nil {
|
|
t.Fatal("prepared worktree accepted an unknown base")
|
|
}
|
|
}
|
|
|
|
// Every read-only operation must report a clear error on a directory that
|
|
// is not a repository, rather than panicking or returning a zero value
|
|
// that reads as "no changes".
|
|
func TestOperationsOnNonRepository(t *testing.T) {
|
|
ctx := context.Background()
|
|
m := &Manager{WorkDir: t.TempDir()}
|
|
dir := t.TempDir()
|
|
|
|
t.Run("CommitAll", func(t *testing.T) {
|
|
if _, err := m.CommitAll(ctx, dir, "msg"); err == nil {
|
|
t.Error("CommitAll() error = nil, want a failure")
|
|
}
|
|
})
|
|
t.Run("ChangedLines", func(t *testing.T) {
|
|
if _, err := m.ChangedLines(ctx, dir, testBase); err == nil {
|
|
t.Error("ChangedLines() error = nil, want a failure")
|
|
}
|
|
})
|
|
t.Run("ChangedFiles", func(t *testing.T) {
|
|
if _, err := m.ChangedFiles(ctx, dir, testBase); err == nil {
|
|
t.Error("ChangedFiles() error = nil, want a failure")
|
|
}
|
|
})
|
|
t.Run("Diff", func(t *testing.T) {
|
|
if _, err := m.Diff(ctx, dir, testBase); err == nil {
|
|
t.Error("Diff() error = nil, want a failure")
|
|
}
|
|
})
|
|
t.Run("Push", func(t *testing.T) {
|
|
if err := m.Push(ctx, dir, "any"); err == nil {
|
|
t.Error("Push() error = nil, want a failure")
|
|
}
|
|
})
|
|
}
|
|
|
|
// The diff must be measured from the merge base, not from the remote tip.
|
|
// Otherwise commits landed on the base branch after the task started are
|
|
// attributed to the task and can trip the diff-size cap.
|
|
func TestSnapshotExportsTrackedFilesWithoutGit(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 9, "feat: snapshot me", "", "feature")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if err := os.MkdirAll(filepath.Join(dir, "pkg"), 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "pkg", "file.go"), []byte("package pkg\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := m.CommitAll(ctx, dir, "feat: add pkg/file.go"); err != nil {
|
|
t.Fatalf("CommitAll() error = %v", err)
|
|
}
|
|
|
|
dest := filepath.Join(t.TempDir(), "snapshot")
|
|
if err := m.Snapshot(ctx, dir, dest); err != nil {
|
|
t.Fatalf("Snapshot() error = %v", err)
|
|
}
|
|
|
|
content, err := os.ReadFile(filepath.Join(dest, "pkg", "file.go"))
|
|
if err != nil {
|
|
t.Fatalf("read snapshotted file: %v", err)
|
|
}
|
|
if string(content) != "package pkg\n" {
|
|
t.Errorf("snapshotted content = %q, want %q", content, "package pkg\n")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dest, ".git")); !os.IsNotExist(err) {
|
|
t.Errorf("Snapshot() destination contains .git, want it stripped (stat err = %v)", err)
|
|
}
|
|
}
|
|
|
|
func TestDiffUsesMergeBaseNotRemoteTip(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 5, "feat: mine", "", "feature")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "mine.txt"), []byte("mine\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := m.CommitAll(ctx, dir, "feat: mine"); err != nil {
|
|
t.Fatalf("CommitAll() error = %v", err)
|
|
}
|
|
|
|
// Land an unrelated commit on the remote base and fetch it, so
|
|
// origin/main moves ahead of where this branch diverged.
|
|
seed := filepath.Join(t.TempDir(), "other")
|
|
sr, err := git.PlainClone(seed, &git.CloneOptions{URL: filepath.Join(host, "acme", "todo.git")})
|
|
if err != nil {
|
|
t.Fatalf("clone for second author: %v", err)
|
|
}
|
|
writeSeedCommit(t, sr, seed, "theirs.txt", "theirs\n", "chore: theirs")
|
|
ref := plumbing.NewBranchReferenceName(testBase)
|
|
if err := sr.Push(&git.PushOptions{
|
|
RemoteName: git.DefaultRemoteName,
|
|
RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec(ref + ":" + ref)},
|
|
}); err != nil {
|
|
t.Fatalf("second author push: %v", err)
|
|
}
|
|
|
|
r, err := git.PlainOpen(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := r.Fetch(&git.FetchOptions{RemoteName: git.DefaultRemoteName}); err != nil {
|
|
t.Fatalf("fetch: %v", err)
|
|
}
|
|
|
|
files, err := m.ChangedFiles(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("ChangedFiles() error = %v", err)
|
|
}
|
|
for _, f := range files {
|
|
if f == "theirs.txt" {
|
|
t.Errorf("ChangedFiles() = %v, includes another author's file; diff is not merge-base relative", files)
|
|
}
|
|
}
|
|
if len(files) != 1 || files[0] != "mine.txt" {
|
|
t.Errorf("ChangedFiles() = %v, want [mine.txt]", files)
|
|
}
|
|
}
|
|
|
|
func TestDiffOperationsRejectUnrelatedBaseHistory(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 6, "feat: task", "", "feature")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "task.txt"), []byte("task\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if changed, err := m.CommitAll(ctx, dir, "feat: task"); err != nil || !changed {
|
|
t.Fatalf("CommitAll() = (%v, %v)", changed, err)
|
|
}
|
|
|
|
orphanDir := t.TempDir()
|
|
orphan, err := git.PlainInit(orphanDir, false, git.WithDefaultBranch(plumbing.NewBranchReferenceName(testBase)))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
writeSeedCommit(t, orphan, orphanDir, "orphan.txt", "unrelated\n", "orphan history")
|
|
if _, err := orphan.CreateRemote(&gitconfig.RemoteConfig{Name: git.DefaultRemoteName, URLs: []string{filepath.Join(host, "acme", "todo.git")}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ref := plumbing.NewBranchReferenceName(testBase)
|
|
if err := orphan.Push(&git.PushOptions{RemoteName: git.DefaultRemoteName, RefSpecs: []gitconfig.RefSpec{gitconfig.RefSpec("+" + ref + ":" + ref)}}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
r, err := git.PlainOpen(dir)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := r.Fetch(&git.FetchOptions{RemoteName: git.DefaultRemoteName, Force: true}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
for _, operation := range []struct {
|
|
name string
|
|
run func() error
|
|
}{
|
|
{name: "Diff", run: func() error { _, err := m.Diff(ctx, dir, testBase); return err }},
|
|
{name: "ChangedFiles", run: func() error { _, err := m.ChangedFiles(ctx, dir, testBase); return err }},
|
|
{name: "ChangedLines", run: func() error { _, err := m.ChangedLines(ctx, dir, testBase); return err }},
|
|
} {
|
|
t.Run(operation.name, func(t *testing.T) {
|
|
if err := operation.run(); err == nil {
|
|
t.Fatal("operation accepted histories without a merge base")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestBranchNaming(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
issue int
|
|
title string
|
|
labels string
|
|
want string
|
|
}{
|
|
{name: "bug label maps to fix", issue: 4, title: "crash on save", labels: "bug", want: "fix/4-crash-on-save"},
|
|
{name: "feature label maps to feat", issue: 9, title: "add export", labels: "feature", want: "feat/9-add-export"},
|
|
{name: "no label defaults to feat", issue: 1, title: "tidy", labels: "", want: "feat/1-tidy"},
|
|
{name: "conventional prefix is not duplicated", issue: 2, title: "fix: broken link", labels: "bug", want: "fix/2-broken-link"},
|
|
{name: "empty title falls back to prefix and issue", issue: 8, title: "", labels: "chore", want: "chore/8"},
|
|
{name: "punctuation collapses to single hyphens", issue: 3, title: "a -- b", labels: "docs", want: "docs/3-a-b"},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
if got := archieBranch(tc.issue, tc.title, tc.labels); got != tc.want {
|
|
t.Errorf("archieBranch() = %q, want %q", got, tc.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCloneURL(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
baseURL string
|
|
want string
|
|
}{
|
|
{
|
|
name: "explicit forge host",
|
|
baseURL: "https://git.example.test",
|
|
want: "https://git.example.test/acme/todo.git",
|
|
},
|
|
{
|
|
// The token must never be embedded in the URL: it travels as
|
|
// an in-process credential instead.
|
|
name: "default github host carries no credentials",
|
|
baseURL: "",
|
|
want: "https://github.com/acme/todo.git",
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
m := &Manager{BaseURL: tc.baseURL, BotUser: "archie-bot", Token: "s3cret"}
|
|
got := m.cloneURL("acme", "todo")
|
|
if got != tc.want {
|
|
t.Errorf("cloneURL() = %q, want %q", got, tc.want)
|
|
}
|
|
if strings.Contains(got, "s3cret") {
|
|
t.Errorf("cloneURL() leaks the token: %q", got)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// A missing forge credential over an HTTP(S) remote must fail with a
|
|
// message naming the missing token as the cause, not a bare git transport
|
|
// error discovered mid-push. Local (non-HTTP) remotes -- the test double
|
|
// used throughout this file -- are unaffected: they never need a token.
|
|
func TestPushWithoutTokenOverHTTPFailsWithClearMessage(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
seeder := newManager(t, host)
|
|
dir, branch, err := seeder.Prepare(ctx, "acme", "todo", testBase, 1, "t", "", "")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
|
|
// Point the already-cloned worktree's origin at an HTTPS remote, as if
|
|
// it had been cloned against a real forge rather than the local test
|
|
// double, then push with no token configured.
|
|
r, err := git.PlainOpen(dir)
|
|
if err != nil {
|
|
t.Fatalf("PlainOpen: %v", err)
|
|
}
|
|
if err := r.DeleteRemote(git.DefaultRemoteName); err != nil {
|
|
t.Fatalf("DeleteRemote: %v", err)
|
|
}
|
|
if _, err := r.CreateRemote(&gitconfig.RemoteConfig{
|
|
Name: git.DefaultRemoteName,
|
|
URLs: []string{"https://forge.example.invalid/acme/todo.git"},
|
|
}); err != nil {
|
|
t.Fatalf("CreateRemote: %v", err)
|
|
}
|
|
|
|
m := &Manager{WorkDir: seeder.WorkDir, BotUser: "archie-bot"}
|
|
err = m.Push(ctx, dir, branch)
|
|
if err == nil {
|
|
t.Fatal("Push() error = nil, want a failure: no token is configured")
|
|
}
|
|
if !strings.Contains(err.Error(), "forge") && !strings.Contains(err.Error(), "token") {
|
|
t.Errorf("Push() error = %q, want it to name the missing forge credential as the cause", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestAuthOmittedWithoutToken(t *testing.T) {
|
|
if opts := (&Manager{BotUser: "archie-bot"}).auth(); opts != nil {
|
|
t.Errorf("auth() = %v with no token, want nil for an anonymous request", opts)
|
|
}
|
|
if opts := (&Manager{BotUser: "archie-bot", Token: "t"}).auth(); len(opts) == 0 {
|
|
t.Error("auth() returned no options despite a configured token")
|
|
}
|
|
}
|
|
|
|
func TestCleanupRemovesWorktree(t *testing.T) {
|
|
m := &Manager{WorkDir: t.TempDir()}
|
|
dir := m.Dir("acme", "todo", 42)
|
|
if err := os.MkdirAll(dir, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := m.Cleanup("acme", "todo", 42); err != nil {
|
|
t.Fatalf("Cleanup() error = %v", err)
|
|
}
|
|
if _, err := os.Stat(dir); !os.IsNotExist(err) {
|
|
t.Error("Cleanup() left the worktree behind")
|
|
}
|
|
// Cleanup of an absent worktree is not an error.
|
|
if err := m.Cleanup("acme", "todo", 42); err != nil {
|
|
t.Errorf("Cleanup() on a missing worktree error = %v, want nil", err)
|
|
}
|
|
}
|
|
|
|
func TestDirDistinguishesRepositoryTuples(t *testing.T) {
|
|
m := &Manager{WorkDir: t.TempDir()}
|
|
first := m.Dir("a-b", "c", 1)
|
|
second := m.Dir("a", "b-c", 1)
|
|
if first == second {
|
|
t.Fatalf("distinct repositories share worktree path %q", first)
|
|
}
|
|
}
|
|
|
|
func TestPrepareMigratesMatchingLegacyWorktree(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
legacy := filepath.Join(m.WorkDir, "acme-todo", "issue-44")
|
|
if _, err := git.PlainCloneContext(ctx, legacy, &git.CloneOptions{
|
|
URL: m.cloneURL("acme", "todo"),
|
|
ReferenceName: plumbing.NewBranchReferenceName(testBase),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(legacy, preparedSentinel), nil, 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
marker := filepath.Join(legacy, ".git", "legacy-marker")
|
|
if err := os.WriteFile(marker, nil, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 44, "feat: migrate", "", "feature")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if dir != m.Dir("acme", "todo", 44) {
|
|
t.Fatalf("Prepare dir = %q, want %q", dir, m.Dir("acme", "todo", 44))
|
|
}
|
|
if _, err := os.Stat(filepath.Join(dir, ".git", "legacy-marker")); err != nil {
|
|
t.Fatalf("legacy worktree was not migrated: %v", err)
|
|
}
|
|
if _, err := os.Stat(legacy); !os.IsNotExist(err) {
|
|
t.Fatalf("legacy path still exists after migration: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPreparePreservesMismatchedLegacyWorktree(t *testing.T) {
|
|
ctx := context.Background()
|
|
desiredHost := newLocalRemote(t, "acme", "todo")
|
|
otherHost := newLocalRemote(t, "other", "widget")
|
|
m := newManager(t, desiredHost)
|
|
legacy := filepath.Join(m.WorkDir, "acme-todo", "issue-45")
|
|
if _, err := git.PlainCloneContext(ctx, legacy, &git.CloneOptions{
|
|
URL: filepath.Join(otherHost, "other", "widget.git"),
|
|
ReferenceName: plumbing.NewBranchReferenceName(testBase),
|
|
}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(legacy, preparedSentinel), nil, 0o644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
marker := filepath.Join(legacy, "keep")
|
|
if err := os.WriteFile(marker, nil, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if _, _, err := m.Prepare(ctx, "acme", "todo", testBase, 45, "feat: safe migration", "", "feature"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := os.Stat(marker); err != nil {
|
|
t.Fatalf("mismatched legacy worktree was altered: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestCleanupHandlesLegacyWorktreesByOrigin(t *testing.T) {
|
|
for _, tc := range []struct {
|
|
name string
|
|
matching bool
|
|
wantExists bool
|
|
}{
|
|
{name: "matching origin is removed", matching: true},
|
|
{name: "mismatched origin is preserved", wantExists: true},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
desiredHost := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, desiredHost)
|
|
cloneURL := m.cloneURL("acme", "todo")
|
|
if !tc.matching {
|
|
otherHost := newLocalRemote(t, "other", "widget")
|
|
cloneURL = filepath.Join(otherHost, "other", "widget.git")
|
|
}
|
|
legacy := filepath.Join(m.WorkDir, "acme-todo", "issue-46")
|
|
if _, err := git.PlainClone(legacy, &git.CloneOptions{URL: cloneURL}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := m.Cleanup("acme", "todo", 46); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
_, err := os.Stat(legacy)
|
|
if tc.wantExists && err != nil {
|
|
t.Fatalf("legacy worktree should remain: %v", err)
|
|
}
|
|
if !tc.wantExists && !os.IsNotExist(err) {
|
|
t.Fatalf("legacy worktree still exists: %v", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// The prepared sentinel must never reach a commit. It previously lived in
|
|
// the working tree, hidden by .git/info/exclude -- which git honours and
|
|
// go-git does not, so it was committed and pushed onto every task branch.
|
|
func TestSentinelIsNeverCommitted(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 21, "feat: thing", "", "feature")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "real.txt"), []byte("x\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := m.CommitAll(ctx, dir, "feat: thing"); err != nil {
|
|
t.Fatalf("CommitAll() error = %v", err)
|
|
}
|
|
|
|
files, err := m.ChangedFiles(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("ChangedFiles() error = %v", err)
|
|
}
|
|
for _, f := range files {
|
|
if strings.Contains(f, "archie-prepared") {
|
|
t.Errorf("the prepared sentinel was committed: ChangedFiles() = %v", files)
|
|
}
|
|
}
|
|
|
|
// It must still exist on disk, or Prepare stops being idempotent.
|
|
if _, err := os.Stat(filepath.Join(dir, preparedSentinel)); err != nil {
|
|
t.Errorf("sentinel missing after commit: %v", err)
|
|
}
|
|
}
|
|
|
|
// The daemon writes the container's boot brief into the task worktree before
|
|
// the container starts. CommitAll stages with go-git's All option, which does
|
|
// not honour .gitignore or .git/info/exclude, so a brief written to the
|
|
// worktree root is swept into the agent's commit and pushed onto the task
|
|
// branch -- the same failure the prepared sentinel hit. It has to live
|
|
// somewhere that can never be tracked.
|
|
func TestTaskBriefIsNeverCommitted(t *testing.T) {
|
|
ctx := context.Background()
|
|
host := newLocalRemote(t, "acme", "todo")
|
|
m := newManager(t, host)
|
|
|
|
dir, _, err := m.Prepare(ctx, "acme", "todo", testBase, 22, "feat: brief", "", "feature")
|
|
if err != nil {
|
|
t.Fatalf("Prepare() error = %v", err)
|
|
}
|
|
if err := container.WriteTaskJSON(dir, container.TaskPayload{
|
|
ID: 22, Owner: "acme", Repo: "todo", Number: 22, Title: "feat: brief",
|
|
}); err != nil {
|
|
t.Fatalf("WriteTaskJSON() error = %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "real.txt"), []byte("x\n"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := m.CommitAll(ctx, dir, "feat: brief"); err != nil {
|
|
t.Fatalf("CommitAll() error = %v", err)
|
|
}
|
|
|
|
files, err := m.ChangedFiles(ctx, dir, testBase)
|
|
if err != nil {
|
|
t.Fatalf("ChangedFiles() error = %v", err)
|
|
}
|
|
for _, f := range files {
|
|
if strings.Contains(f, "task.json") {
|
|
t.Errorf("the task brief was committed: ChangedFiles() = %v", files)
|
|
}
|
|
}
|
|
|
|
// The agent still has to be able to read it off its mount.
|
|
if _, err := os.Stat(filepath.Join(dir, ".git", "task.json")); err != nil {
|
|
t.Errorf("brief missing after commit: %v", err)
|
|
}
|
|
}
|