beads/cmd/bd/worktree_remove_windows_test.go
ecuthiell cd25e0919d
fix(worktree): add explicit merge containment (#4929)
* fix(worktree): add explicit merge containment (#4919)

Allow worktree removal to verify HEAD containment against a caller-selected ref while failing closed when no upstream can be resolved.

Agent-Signature: codex-tui-gpt-5.6-sol-ultra on behalf of Ewen Cuthiell

* fix(worktree): preserve Windows path identity (#4919)

Git for Windows canonicalizes an 8.3 ancestor before recording worktree paths. Match two missing paths only when their exact unresolved suffixes peel to stat-proven identical ancestors, while keeping existing-versus-missing identities distinct.

Force ordinal matching for the destructive Git selector so a final-boundary target disappearance or core.ignorecase change cannot redirect removal to a case-variant sibling. Add real-process coverage for the short-path lookup, ordinary case-insensitive repositories, the selector race, and a restoration hook that is proven to execute.

Agent-Signature: codex-tui-gpt-5.6-sol-ultra on behalf of Ewen Cuthiell

---------

Co-authored-by: matt wilkie <maphew@gmail.com>
2026-07-25 17:05:48 -07:00

481 lines
17 KiB
Go

package main
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
)
func TestWorktreeRemoveWindowsOrdinalGitSelectorRemovesOrdinaryWorktree(t *testing.T) {
fixture := newWorktreeRemovalFixture(t)
fixture.git(t, fixture.repo, "config", "core.ignorecase", "true")
result := runWorktreeRemoveProcess(
t,
fixture.repo,
nil,
fixture.lane,
"--merged-into",
"main",
)
result.requireSuccess(t)
fixture.assertRemovedAndCleaned(t)
}
func TestWorktreeRemoveWindowsOrdinalGitSelectorProtectsCaseSiblingAfterTargetDisappears(
t *testing.T,
) {
fixture, upperLane, _ := newWindowsCaseSensitiveRemovalFixture(t, true)
upperFingerprint, err := fingerprintWorktreeFilesystem(upperLane)
if err != nil {
t.Fatalf("fingerprint uppercase sibling: %v", err)
}
lowerFingerprint, err := fingerprintWorktreeFilesystem(fixture.lane)
if err != nil {
t.Fatalf("fingerprint lowercase target: %v", err)
}
upperBranch := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane")
lowerBranch := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane")
result := runWorktreeRemoveProcess(
t,
fixture.repo,
[]string{
worktreeRemoveHelperHookEnv + "=" + worktreeRemoveHookCaseRace,
worktreeRemoveHelperMain + "=" + fixture.repo,
worktreeRemoveHelperTarget + "=" + fixture.lane,
},
fixture.lane,
"--merged-into",
"main",
)
result.requireSuccess(t)
movedLower := fixture.lane + "-moved"
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase sibling registration was removed after lowercase target disappeared")
}
if windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("disappeared lowercase target remains registered")
}
if _, err := os.Stat(upperLane); err != nil {
t.Fatalf("uppercase sibling path was not preserved: %v", err)
}
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatalf("lowercase target path unexpectedly exists: %v", err)
}
if _, err := os.Stat(movedLower); err != nil {
t.Fatalf("interleaved moved target was not preserved: %v", err)
}
gotUpperFingerprint, err := fingerprintWorktreeFilesystem(upperLane)
if err != nil {
t.Fatalf("fingerprint preserved uppercase sibling: %v", err)
}
if gotUpperFingerprint != upperFingerprint {
t.Fatal("uppercase sibling changed after lowercase target disappeared")
}
gotLowerFingerprint, err := fingerprintWorktreeFilesystem(movedLower)
if err != nil {
t.Fatalf("fingerprint interleaved moved target: %v", err)
}
if gotLowerFingerprint != lowerFingerprint {
t.Fatal("interleaved moved target changed during exact-registration removal")
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"); got != upperBranch {
t.Fatalf("uppercase branch changed: got %s, want %s", got, upperBranch)
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane"); got != lowerBranch {
t.Fatalf("lowercase branch changed: got %s, want %s", got, lowerBranch)
}
if got := fixture.git(t, fixture.repo, "config", "--get", "core.ignorecase"); got != "true" {
t.Fatalf("race hook did not change core.ignorecase: got %q", got)
}
wantGitignore := "# bd worktree\nLane/\nignored/\n"
if got := fixture.readGitignore(t); got != wantGitignore {
t.Fatalf(".gitignore cleanup targeted the wrong case sibling\ngot: %q\nwant: %q", got, wantGitignore)
}
}
func TestWorktreeRemoveWindowsCaseSensitiveSiblingPaths(t *testing.T) {
fixture, upperLane, _ := newWindowsCaseSensitiveRemovalFixture(t, true)
upperInfo, err := os.Stat(upperLane)
if err != nil {
t.Fatalf("stat uppercase sibling: %v", err)
}
lowerInfo, err := os.Stat(fixture.lane)
if err != nil {
t.Fatalf("stat lowercase target: %v", err)
}
if os.SameFile(upperInfo, lowerInfo) {
t.Fatal("case-sensitive siblings unexpectedly identify the same directory")
}
if sameWorktreePath(upperLane, fixture.lane) {
t.Fatal("sameWorktreePath conflated stat-proven case-sensitive siblings")
}
result := runWorktreeRemoveProcess(
t,
fixture.repo,
nil,
fixture.lane,
"--merged-into",
"main",
)
result.requireSuccess(t)
if windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("lowercase target remains registered")
}
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatalf("lowercase target path still exists: %v", err)
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase sibling was removed instead of the exact lowercase target")
}
if _, err := os.Stat(upperLane); err != nil {
t.Fatalf("uppercase sibling path was not preserved: %v", err)
}
fixture.git(t, fixture.repo, "rev-parse", "--verify", "refs/heads/lane")
fixture.git(t, fixture.repo, "rev-parse", "--verify", "refs/heads/upper-lane")
wantGitignore := "# bd worktree\nLane/\nignored/\n"
if got := fixture.readGitignore(t); got != wantGitignore {
t.Fatalf(".gitignore cleanup targeted the wrong sibling\ngot: %q\nwant: %q", got, wantGitignore)
}
}
func TestWorktreeRemoveWindowsMissingCaseVariantRefuses(t *testing.T) {
fixture, upperLane, gitignore := newWindowsCaseSensitiveRemovalFixture(t, false)
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatalf("lowercase target unexpectedly exists: %v", err)
}
if sameWorktreePath(upperLane, fixture.lane) {
t.Fatal("sameWorktreePath aliased an existing path to a missing case variant")
}
beforeRegistry := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z")
beforeHead := fixture.git(t, upperLane, "rev-parse", "HEAD")
beforeBranch := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane")
beforeFingerprint, err := fingerprintWorktreeFilesystem(upperLane)
if err != nil {
t.Fatalf("fingerprint uppercase worktree: %v", err)
}
result := runWorktreeRemoveProcess(
t,
fixture.repo,
nil,
fixture.lane,
"--merged-into",
"main",
)
result.requireFailure(t, "registered worktree not found")
if got := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z"); got != beforeRegistry {
t.Fatalf("worktree registry changed on missing-case refusal\ngot: %q\nwant: %q", got, beforeRegistry)
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase worktree was removed for a missing lowercase request")
}
if got := fixture.git(t, upperLane, "rev-parse", "HEAD"); got != beforeHead {
t.Fatalf("uppercase worktree HEAD changed: got %s, want %s", got, beforeHead)
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"); got != beforeBranch {
t.Fatalf("uppercase branch changed: got %s, want %s", got, beforeBranch)
}
afterFingerprint, err := fingerprintWorktreeFilesystem(upperLane)
if err != nil {
t.Fatalf("fingerprint preserved uppercase worktree: %v", err)
}
if afterFingerprint != beforeFingerprint {
t.Fatal("uppercase worktree bytes or metadata changed on missing-case refusal")
}
if got := fixture.readGitignore(t); got != gitignore {
t.Fatalf(".gitignore changed on missing-case refusal\ngot: %q\nwant: %q", got, gitignore)
}
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatalf("missing lowercase path was created: %v", err)
}
}
func TestWorktreeRemoveWindowsSinglePrunableCaseVariantRefuses(t *testing.T) {
fixture, upperLane, upperStage, lowerStage, _ :=
newWindowsPrunableCaseVariantFixture(t, false)
if sameWorktreePath(upperLane, fixture.lane) {
t.Fatal("sameWorktreePath aliased two absent case-variant paths")
}
before := captureWindowsPrunableState(t, fixture, upperStage, lowerStage)
result := runWorktreeRemoveProcess(
t,
fixture.repo,
nil,
fixture.lane,
"--force",
)
result.requireFailure(t, "registered worktree not found")
assertWindowsPrunableState(t, fixture, upperLane, upperStage, lowerStage, before)
}
func TestWorktreeRemoveWindowsTwoPrunableCaseVariantsStayDistinct(t *testing.T) {
fixture, upperLane, upperStage, lowerStage, _ :=
newWindowsPrunableCaseVariantFixture(t, true)
if sameWorktreePath(upperLane, fixture.lane) {
t.Fatal("sameWorktreePath collapsed two registered absent case variants")
}
before := captureWindowsPrunableState(t, fixture, upperStage, lowerStage)
result := runWorktreeRemoveProcess(
t,
fixture.repo,
nil,
fixture.lane,
"--force",
)
result.requireFailure(t, "failed to resolve target git directory")
assertWindowsPrunableState(t, fixture, upperLane, upperStage, lowerStage, before)
}
func TestWorktreeRemoveWindowsPrunableWrongCaseRestorationRefuses(t *testing.T) {
fixture, upperLane, upperStage, lowerStage, _ :=
newWindowsPrunableCaseVariantFixture(t, true)
before := captureWindowsPrunableState(t, fixture, upperStage, lowerStage)
adminFingerprint, err := fingerprintWorktreeFilesystem(
filepath.Join(fixture.repo, ".git", "worktrees"),
)
if err != nil {
t.Fatalf("fingerprint worktree registry: %v", err)
}
sentinel := filepath.Join(t.TempDir(), "restore-hook-reached")
result := runWorktreeRemoveProcess(
t,
fixture.repo,
[]string{
worktreeRemoveHelperHookEnv + "=" + worktreeRemoveHookRestore,
worktreeRemoveHelperTarget + "=" + upperLane,
worktreeRemoveHelperRestore + "=" + upperStage,
worktreeRemoveHelperSentinel + "=" + sentinel,
},
fixture.lane,
"--force",
)
result.requireFailure(t, "failed to resolve target git directory")
if content, err := os.ReadFile(sentinel); err != nil {
t.Fatalf("restore hook did not publish its sentinel: %v", err)
} else if string(content) != "reached\n" {
t.Fatalf("restore hook sentinel = %q, want %q", content, "reached\n")
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) ||
!windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("wrong-case restoration removed a registered case variant")
}
gotAdminFingerprint, err := fingerprintWorktreeFilesystem(
filepath.Join(fixture.repo, ".git", "worktrees"),
)
if err != nil {
t.Fatalf("fingerprint preserved worktree registry: %v", err)
}
if gotAdminFingerprint != adminFingerprint {
t.Fatal("worktree administrative registry changed after wrong-case restoration")
}
if _, err := os.Stat(upperStage); !os.IsNotExist(err) {
t.Fatalf("uppercase staging path still exists after restoration: %v", err)
}
upperFingerprint, err := fingerprintWorktreeFilesystem(upperLane)
if err != nil {
t.Fatalf("fingerprint restored uppercase worktree: %v", err)
}
if upperFingerprint != before.upperFingerprint {
t.Fatal("restored uppercase worktree changed during lowercase refusal")
}
lowerFingerprint, err := fingerprintWorktreeFilesystem(lowerStage)
if err != nil {
t.Fatalf("fingerprint staged lowercase worktree: %v", err)
}
if lowerFingerprint != before.lowerFingerprint {
t.Fatal("staged lowercase worktree changed during wrong-case restoration")
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"); got != before.upperBranchOID {
t.Fatalf("uppercase branch changed: got %s, want %s", got, before.upperBranchOID)
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane"); got != before.lowerBranchOID {
t.Fatalf("lowercase branch changed: got %s, want %s", got, before.lowerBranchOID)
}
if got := fixture.readGitignore(t); got != before.gitignore {
t.Fatalf(".gitignore changed after wrong-case restoration\ngot: %q\nwant: %q", got, before.gitignore)
}
}
type windowsPrunableState struct {
registry string
upperBranchOID string
lowerBranchOID string
gitignore string
upperFingerprint string
lowerFingerprint string
}
func captureWindowsPrunableState(
t *testing.T,
fixture *worktreeRemovalFixture,
upperStage string,
lowerStage string,
) windowsPrunableState {
t.Helper()
state := windowsPrunableState{
registry: fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z"),
upperBranchOID: fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"),
gitignore: fixture.readGitignore(t),
}
var err error
state.upperFingerprint, err = fingerprintWorktreeFilesystem(upperStage)
if err != nil {
t.Fatalf("fingerprint staged uppercase worktree: %v", err)
}
if lowerStage != "" {
state.lowerBranchOID = fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane")
state.lowerFingerprint, err = fingerprintWorktreeFilesystem(lowerStage)
if err != nil {
t.Fatalf("fingerprint staged lowercase worktree: %v", err)
}
}
return state
}
func assertWindowsPrunableState(
t *testing.T,
fixture *worktreeRemovalFixture,
upperLane string,
upperStage string,
lowerStage string,
want windowsPrunableState,
) {
t.Helper()
got := captureWindowsPrunableState(t, fixture, upperStage, lowerStage)
if got != want {
t.Fatalf("prunable worktree state mutated on refusal\ngot: %#v\nwant: %#v", got, want)
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase prunable registration was removed")
}
if _, err := os.Stat(upperLane); !os.IsNotExist(err) {
t.Fatalf("uppercase registry path unexpectedly exists: %v", err)
}
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatalf("lowercase registry path unexpectedly exists: %v", err)
}
if lowerStage != "" && !windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("lowercase prunable registration was removed")
}
}
func newWindowsPrunableCaseVariantFixture(
t *testing.T,
includeLower bool,
) (*worktreeRemovalFixture, string, string, string, string) {
t.Helper()
fixture, upperLane, gitignore := newWindowsCaseSensitiveRemovalFixture(t, includeLower)
stageRoot := filepath.Join(filepath.Dir(fixture.repo), "staged")
if err := os.Mkdir(stageRoot, 0755); err != nil {
t.Fatalf("create staging directory: %v", err)
}
upperStage := filepath.Join(stageRoot, "upper")
if err := os.Rename(upperLane, upperStage); err != nil {
t.Fatalf("stage uppercase worktree: %v", err)
}
lowerStage := ""
if includeLower {
lowerStage = filepath.Join(stageRoot, "lower")
if err := os.Rename(fixture.lane, lowerStage); err != nil {
t.Fatalf("stage lowercase worktree: %v", err)
}
}
return fixture, upperLane, upperStage, lowerStage, gitignore
}
func newWindowsCaseSensitiveRemovalFixture(
t *testing.T,
includeLower bool,
) (*worktreeRemovalFixture, string, string) {
t.Helper()
root := t.TempDir()
requireWindowsCaseSensitiveDirectory(t, root)
fixture := &worktreeRemovalFixture{
repo: filepath.Join(root, "repo"),
gitignoreEntry: "lane",
}
fixture.lane = filepath.Join(fixture.repo, fixture.gitignoreEntry)
upperLane := filepath.Join(fixture.repo, "Lane")
if err := os.Mkdir(fixture.repo, 0755); err != nil {
t.Fatalf("create repository: %v", err)
}
fixture.git(t, fixture.repo, "init")
fixture.git(t, fixture.repo, "config", "user.name", worktreeRemoveTestActorName)
fixture.git(t, fixture.repo, "config", "user.email", worktreeRemoveTestActorEmail)
fixture.git(t, fixture.repo, "config", "commit.gpgsign", "false")
fixture.git(t, fixture.repo, "config", "core.ignorecase", "false")
fixture.git(t, fixture.repo, "config", "core.hooksPath", ".git/hooks")
fixture.git(t, fixture.repo, "symbolic-ref", "HEAD", "refs/heads/main")
gitignore := "# bd worktree\nLane/\nignored/\n"
if includeLower {
gitignore = "# bd worktree\nLane/\n# bd worktree\nlane/\nignored/\n"
}
if err := os.WriteFile(
filepath.Join(fixture.repo, ".gitignore"),
[]byte(gitignore),
0644,
); err != nil {
t.Fatalf("write .gitignore: %v", err)
}
fixture.git(t, fixture.repo, "add", ".gitignore")
fixture.git(t, fixture.repo, "commit", "-m", "base")
fixture.baseOID = fixture.git(t, fixture.repo, "rev-parse", "HEAD")
fixture.git(t, fixture.repo, "worktree", "add", "-b", "upper-lane", upperLane)
if includeLower {
fixture.git(t, fixture.repo, "worktree", "add", "-b", "lane", fixture.lane)
}
return fixture, upperLane, gitignore
}
func windowsRegisteredWorktreePathExact(
t *testing.T,
fixture *worktreeRemovalFixture,
want string,
) bool {
t.Helper()
want = filepath.Clean(want)
wantParent, err := os.Stat(filepath.Dir(want))
if err != nil {
t.Fatalf("stat expected registry parent: %v", err)
}
output := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z")
for _, field := range strings.Split(output, "\x00") {
if !strings.HasPrefix(field, "worktree ") {
continue
}
registered := filepath.Clean(strings.TrimPrefix(field, "worktree "))
if filepath.Base(registered) != filepath.Base(want) {
continue
}
registeredParent, err := os.Stat(filepath.Dir(registered))
if err == nil && os.SameFile(registeredParent, wantParent) {
return true
}
}
return false
}
func requireWindowsCaseSensitiveDirectory(t *testing.T, path string) {
t.Helper()
set := exec.Command("fsutil.exe", "file", "SetCaseSensitiveInfo", path, "enable")
if output, err := set.CombinedOutput(); err != nil {
t.Fatalf(
"native Windows worktree boundary requires per-directory case sensitivity: %v\n%s",
err,
strings.TrimSpace(string(output)),
)
}
}