beads/cmd/bd/worktree_remove_git_windows_test.go

237 lines
9.9 KiB
Go

package main
import (
"os"
"os/exec"
"path/filepath"
"strings"
"testing"
)
func TestWorktreeRemoveGitAdapterWindowsOrdinaryIgnoreCaseRemoval(t *testing.T) {
fixture := newWorktreeRemovalFixture(t)
fixture.git(t, fixture.repo, "config", "core.ignorecase", "true")
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "main", worktreeRemoveHooks{}); err != nil {
t.Fatal(err)
}
fixture.assertRemovedAndCleaned(t)
}
func TestWorktreeRemoveGitAdapterWindowsMissingCaseVariantRefuses(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("existing and missing case variants aliased")
}
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.Fatal(err)
}
err = runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "main", worktreeRemoveHooks{})
requireWorktreeRemoveGitAdapterFailure(t, err, "registered worktree not found")
if got := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z"); got != beforeRegistry {
t.Fatal("registry changed")
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase worktree was removed")
}
if got := fixture.git(t, upperLane, "rev-parse", "HEAD"); got != beforeHead {
t.Fatal("uppercase HEAD changed")
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"); got != beforeBranch {
t.Fatal("uppercase branch changed")
}
if got, err := fingerprintWorktreeFilesystem(upperLane); err != nil || got != beforeFingerprint {
t.Fatalf("uppercase worktree changed: %v", err)
}
if got := fixture.readGitignore(t); got != gitignore {
t.Fatal(".gitignore changed")
}
if _, statErr := os.Stat(fixture.lane); !os.IsNotExist(statErr) {
t.Fatalf("lowercase target exists after refusal: %v", statErr)
}
}
func TestWorktreeRemoveGitAdapterWindowsPrunableCaseVariants(t *testing.T) {
for _, test := range []struct {
name string
includeLower bool
want string
}{
{"single variant", false, "registered worktree not found"},
{"two variants", true, "failed to resolve target git directory"},
} {
t.Run(test.name, func(t *testing.T) {
fixture, upperLane, upperStage, lowerStage, _ := newWindowsPrunableCaseVariantFixture(t, test.includeLower)
if sameWorktreePath(upperLane, fixture.lane) {
t.Fatal("case variants aliased")
}
before := captureWindowsPrunableState(t, fixture, upperStage, lowerStage)
err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, true, "", worktreeRemoveHooks{})
requireWorktreeRemoveGitAdapterFailure(t, err, test.want)
assertWindowsPrunableState(t, fixture, upperLane, upperStage, lowerStage, before)
})
}
}
func TestWorktreeRemoveGitAdapterWindowsPrunableWrongCaseRestorationRefuses(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.Fatal(err)
}
hooks := worktreeRemoveHooks{afterTargetResolution: func() error { return os.Rename(upperStage, upperLane) }}
err = runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, true, "", hooks)
requireWorktreeRemoveGitAdapterFailure(t, err, "failed to resolve target git directory")
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) || !windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("registered case variant was removed")
}
if got, err := fingerprintWorktreeFilesystem(filepath.Join(fixture.repo, ".git", "worktrees")); err != nil || got != adminFingerprint {
t.Fatalf("registry changed: %v", err)
}
if _, err := os.Stat(upperStage); !os.IsNotExist(err) {
t.Fatalf("staging path remains: %v", err)
}
if got, err := fingerprintWorktreeFilesystem(upperLane); err != nil || got != before.upperFingerprint {
t.Fatalf("uppercase worktree changed: %v", err)
}
if got, err := fingerprintWorktreeFilesystem(lowerStage); err != nil || got != before.lowerFingerprint {
t.Fatalf("lowercase worktree changed: %v", err)
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/upper-lane"); got != before.upperBranchOID {
t.Fatal("uppercase branch changed")
}
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane"); got != before.lowerBranchOID {
t.Fatal("lowercase branch changed")
}
if got := fixture.readGitignore(t); got != before.gitignore {
t.Fatal(".gitignore changed")
}
}
type windowsPrunableState struct{ registry, upperBranchOID, lowerBranchOID, gitignore, upperFingerprint, lowerFingerprint string }
func captureWindowsPrunableState(t *testing.T, fixture *worktreeRemovalFixture, upperStage, 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.Fatal(err)
}
if lowerStage != "" {
state.lowerBranchOID = fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane")
state.lowerFingerprint, err = fingerprintWorktreeFilesystem(lowerStage)
if err != nil {
t.Fatal(err)
}
}
return state
}
func assertWindowsPrunableState(t *testing.T, fixture *worktreeRemovalFixture, upperLane, upperStage, lowerStage string, want windowsPrunableState) {
t.Helper()
if got := captureWindowsPrunableState(t, fixture, upperStage, lowerStage); got != want {
t.Fatalf("prunable state mutated\ngot: %#v\nwant: %#v", got, want)
}
if !windowsRegisteredWorktreePathExact(t, fixture, upperLane) {
t.Fatal("uppercase registration removed")
}
if _, err := os.Stat(upperLane); !os.IsNotExist(err) {
t.Fatal("uppercase registry path exists")
}
if _, err := os.Stat(fixture.lane); !os.IsNotExist(err) {
t.Fatal("lowercase registry path exists")
}
if lowerStage != "" && !windowsRegisteredWorktreePathExact(t, fixture, fixture.lane) {
t.Fatal("lowercase registration 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.Fatal(err)
}
upperStage := filepath.Join(stageRoot, "upper")
if err := os.Rename(upperLane, upperStage); err != nil {
t.Fatal(err)
}
lowerStage := ""
if includeLower {
lowerStage = filepath.Join(stageRoot, "lower")
if err := os.Rename(fixture.lane, lowerStage); err != nil {
t.Fatal(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.Fatal(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.Fatal(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.Fatal(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)))
}
}