237 lines
9.9 KiB
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)))
|
|
}
|
|
}
|