538 lines
21 KiB
Go
538 lines
21 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/steveyegge/beads/internal/worktreeremove"
|
|
)
|
|
|
|
// runWorktreeRemoveGitAdapter exercises the real Git and filesystem adapter
|
|
// without the child-process Cobra harness. Command grammar has its own unit
|
|
// coverage; these contracts own the adapter's observations and mutations.
|
|
func runWorktreeRemoveGitAdapter(
|
|
t *testing.T,
|
|
dir, name string,
|
|
force bool,
|
|
mergedInto string,
|
|
hooks worktreeRemoveHooks,
|
|
) error {
|
|
t.Helper()
|
|
if force && mergedInto != "" {
|
|
t.Fatalf("force adapter test requested unreachable comparator state %q", mergedInto)
|
|
}
|
|
t.Chdir(dir)
|
|
options := &worktreeRemoveOptions{
|
|
force: singleWorktreeBoolFlag{name: "force", value: force, set: force},
|
|
}
|
|
if mergedInto != "" {
|
|
options.mergedInto = singleWorktreeStringFlag{name: "merged-into", value: mergedInto, set: true}
|
|
}
|
|
mode := worktreeremove.Normal
|
|
if force {
|
|
mode = worktreeremove.Force
|
|
}
|
|
adapter := &gitWorktreeRemovalAdapter{name: name, options: options, hooks: hooks}
|
|
return runWorktreeRemovalOrchestration(
|
|
context.Background(),
|
|
worktreeRemovalRequest{mode: mode},
|
|
adapter,
|
|
adapter,
|
|
cliWorktreeRemovalPresenter{},
|
|
)
|
|
}
|
|
|
|
func requireWorktreeRemoveGitAdapterFailure(t *testing.T, err error, want string) {
|
|
t.Helper()
|
|
if err == nil || !strings.Contains(err.Error(), want) {
|
|
t.Fatalf("adapter removal error = %v, want substring %q", err, want)
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterSafetyRefusals(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
setup func(*testing.T, *worktreeRemovalFixture)
|
|
force bool
|
|
compare func(*worktreeRemovalFixture) string
|
|
wantErr string
|
|
}{
|
|
{"ignored status", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.writeLaneFile(t, filepath.Join("ignored", "cache.bin"), "ignored\n")
|
|
}, false, func(f *worktreeRemovalFixture) string { return "main" }, "modified, untracked, or ignored files"},
|
|
{"missing upstream", nil, false, nil, "no single resolvable upstream"},
|
|
{"configured upstream tag collision", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.setUpstream(t)
|
|
f.commitLane(t, "ahead of upstream")
|
|
f.git(t, f.repo, "tag", "heads/main", "lane")
|
|
}, false, nil, "commits not contained in its configured upstream"},
|
|
{"not contained", func(t *testing.T, f *worktreeRemovalFixture) { f.commitLane(t, "uncontained") }, false, func(f *worktreeRemovalFixture) string { return "main" }, "is not contained"},
|
|
{"HEAD pseudoref", nil, false, func(f *worktreeRemovalFixture) string { return "HEAD" }, "worktree-local pseudoref"},
|
|
{"ORIG_HEAD pseudoref", func(t *testing.T, f *worktreeRemovalFixture) { f.writeTargetPseudoref(t, "ORIG_HEAD") }, false, func(f *worktreeRemovalFixture) string { return "ORIG_HEAD" }, "worktree-local pseudoref"},
|
|
{"future pseudoref", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.writeTargetPseudoref(t, "FUTURE_HEAD")
|
|
f.git(t, f.repo, "branch", "FUTURE_HEAD")
|
|
}, false, func(f *worktreeRemovalFixture) string { return "FUTURE_HEAD" }, "worktree-local pseudoref"},
|
|
{"irregular pseudoref", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.writeTargetPseudoref(t, "BISECT_EXPECTED_REV")
|
|
f.git(t, f.repo, "branch", "BISECT_EXPECTED_REV")
|
|
}, false, func(f *worktreeRemovalFixture) string { return "BISECT_EXPECTED_REV" }, "worktree-local pseudoref"},
|
|
{"refs worktree", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.git(t, f.repo, "update-ref", "refs/worktree/proof", f.baseOID)
|
|
}, false, func(f *worktreeRemovalFixture) string { return "refs/worktree/proof" }, "worktree-local ref namespace"},
|
|
{"refs bisect", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.git(t, f.repo, "update-ref", "refs/bisect/proof", f.baseOID)
|
|
}, false, func(f *worktreeRemovalFixture) string { return "refs/bisect/proof" }, "worktree-local ref namespace"},
|
|
{"refs rewritten", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.git(t, f.repo, "update-ref", "refs/rewritten/proof", f.baseOID)
|
|
}, false, func(f *worktreeRemovalFixture) string { return "refs/rewritten/proof" }, "worktree-local ref namespace"},
|
|
{"revision expression", nil, false, func(f *worktreeRemovalFixture) string { return "HEAD~1" }, "not an accepted ref name or full commit object ID"},
|
|
{"missing full ref", nil, false, func(f *worktreeRemovalFixture) string { return "refs/heads/missing" }, "does not resolve to a commit"},
|
|
{"target branch", nil, false, func(f *worktreeRemovalFixture) string { return "refs/heads/lane" }, "cannot independently prove containment"},
|
|
{"target HEAD OID", nil, false, func(f *worktreeRemovalFixture) string { return f.baseOID }, "target HEAD itself"},
|
|
{"ambiguous short ref", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.git(t, f.repo, "branch", "comparison")
|
|
f.git(t, f.repo, "tag", "comparison")
|
|
}, false, func(f *worktreeRemovalFixture) string { return "comparison" }, "is ambiguous"},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
if test.setup != nil {
|
|
test.setup(t, fixture)
|
|
}
|
|
before := fixture.snapshot(t)
|
|
compare := ""
|
|
if test.compare != nil {
|
|
compare = test.compare(fixture)
|
|
}
|
|
err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, test.force, compare, worktreeRemoveHooks{})
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, test.wantErr)
|
|
fixture.assertSnapshot(t, before)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterComparatorAndCleanupContracts(t *testing.T) {
|
|
t.Run("configured upstream success", func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained upstream")
|
|
fixture.mergeLaneIntoMain(t)
|
|
fixture.setUpstream(t)
|
|
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "", worktreeRemoveHooks{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.assertRemovedAndCleaned(t)
|
|
})
|
|
for _, comparator := range []struct{ name, value string }{{"short ref", "main"}, {"full ref", "refs/heads/main"}} {
|
|
t.Run(comparator.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained")
|
|
fixture.mergeLaneIntoMain(t)
|
|
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, comparator.value, worktreeRemoveHooks{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.assertRemovedAndCleaned(t)
|
|
})
|
|
}
|
|
t.Run("full descendant object ID", func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained by object")
|
|
fixture.mergeLaneIntoMain(t)
|
|
fixture.git(t, fixture.repo, "commit", "--allow-empty", "-m", "descendant")
|
|
comparator := fixture.git(t, fixture.repo, "rev-parse", "main")
|
|
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, comparator, worktreeRemoveHooks{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.assertRemovedAndCleaned(t)
|
|
})
|
|
for _, test := range []struct {
|
|
name, path string
|
|
body func(*testing.T, *worktreeRemovalFixture)
|
|
}{
|
|
{"force ignored removal", "lane", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.writeLaneFile(t, filepath.Join("ignored", "cache.bin"), "ignored\n")
|
|
}},
|
|
{"nested cleanup", "nested/lane", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.commitLane(t, "contained nested")
|
|
f.mergeLaneIntoMain(t)
|
|
}},
|
|
{"CRLF cleanup", "lane", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
f.commitLane(t, "contained")
|
|
f.mergeLaneIntoMain(t)
|
|
before := "# bd worktree\r\nlane/\r\n# bd worktree\r\nother/\r\n# unrelated\r\nignored/\r\n"
|
|
if err := os.WriteFile(filepath.Join(f.repo, ".gitignore"), []byte(before), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{"leading space cleanup", " lane", func(t *testing.T, f *worktreeRemovalFixture) {
|
|
if err := os.WriteFile(filepath.Join(f.repo, ".gitignore"), []byte("# bd worktree\n lane/\n# bd worktree\nlane/\nignored/\n"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixtureAt(t, test.path)
|
|
test.body(t, fixture)
|
|
force := test.name == "force ignored removal"
|
|
comparator := "main"
|
|
if force {
|
|
comparator = ""
|
|
}
|
|
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, force, comparator, worktreeRemoveHooks{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.assertRemovedAndCleaned(t)
|
|
if test.name == "CRLF cleanup" && fixture.readGitignore(t) != "# bd worktree\r\nother/\r\n# unrelated\r\nignored/\r\n" {
|
|
t.Fatal("CRLF cleanup changed unrelated bytes")
|
|
}
|
|
if test.name == "leading space cleanup" && fixture.readGitignore(t) != "# bd worktree\nlane/\nignored/\n" {
|
|
t.Fatal("leading-space cleanup conflated entries")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterScrubsEveryPoisonedEnvironmentKey(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained")
|
|
fixture.mergeLaneIntoMain(t)
|
|
decoy := filepath.Join(t.TempDir(), "decoy")
|
|
if err := os.MkdirAll(decoy, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.git(t, decoy, "init")
|
|
shallow := filepath.Join(t.TempDir(), "shallow")
|
|
if err := os.WriteFile(shallow, nil, 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for key, value := range map[string]string{
|
|
"GIT_DIR": filepath.Join(decoy, ".git"), "GIT_WORK_TREE": decoy, "GIT_COMMON_DIR": filepath.Join(decoy, ".git"), "GIT_INDEX_FILE": filepath.Join(decoy, ".git", "index"), "GIT_OBJECT_DIRECTORY": filepath.Join(decoy, ".git", "objects"), "GIT_ALTERNATE_OBJECT_DIRECTORIES": filepath.Join(decoy, ".git", "objects"), "GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "core.worktree", "GIT_CONFIG_VALUE_0": decoy, "GIT_EXEC_PATH": t.TempDir(), "GIT_SHALLOW_FILE": shallow, "GIT_REPLACE_REF_BASE": "refs/heads", "GIT_NO_REPLACE_OBJECTS": "0",
|
|
} {
|
|
t.Setenv(key, value)
|
|
}
|
|
if err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "main", worktreeRemoveHooks{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fixture.assertRemovedAndCleaned(t)
|
|
if _, err := os.Stat(filepath.Join(decoy, ".git")); err != nil {
|
|
t.Fatalf("poisoned environment damaged decoy: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterRejectsForgedMutationIdentities(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
t.Chdir(fixture.repo)
|
|
options := &worktreeRemoveOptions{
|
|
force: singleWorktreeBoolFlag{name: "force"},
|
|
mergedInto: singleWorktreeStringFlag{
|
|
name: "merged-into",
|
|
value: "main",
|
|
set: true,
|
|
},
|
|
}
|
|
adapter := &gitWorktreeRemovalAdapter{
|
|
name: fixture.lane,
|
|
options: options,
|
|
}
|
|
if _, err := adapter.Prepare(context.Background(), worktreeRemovalRequest{mode: worktreeremove.Normal}); err != nil {
|
|
t.Fatalf("prepare real adapter: %v", err)
|
|
}
|
|
if adapter.plan == nil || adapter.plan.gitignoreCleanup == nil {
|
|
t.Fatal("real adapter did not prepare target and managed-ignore identities")
|
|
}
|
|
before := fixture.snapshot(t)
|
|
|
|
for _, mutation := range []worktreeremove.Mutation{
|
|
{TargetPath: fixture.lane + "-forged", Force: false},
|
|
{TargetPath: fixture.lane, Force: true},
|
|
} {
|
|
err := adapter.Remove(context.Background(), mutation)
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "unapproved mutation")
|
|
fixture.assertSnapshot(t, before)
|
|
}
|
|
|
|
err := adapter.Cleanup(
|
|
context.Background(),
|
|
worktreeremove.Cleanup{Entry: adapter.plan.gitignoreCleanup.entry + "-forged"},
|
|
)
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "approved identity")
|
|
fixture.assertSnapshot(t, before)
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterClassifiesRealRemovalFailures(t *testing.T) {
|
|
t.Run("stable locked target is unchanged", func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained locked worktree")
|
|
fixture.mergeLaneIntoMain(t)
|
|
fixture.git(t, fixture.repo, "worktree", "lock", "--reason", "test lock", fixture.lane)
|
|
before := fixture.snapshot(t)
|
|
|
|
err := runWorktreeRemoveGitAdapter(
|
|
t,
|
|
fixture.repo,
|
|
fixture.lane,
|
|
false,
|
|
"main",
|
|
worktreeRemoveHooks{},
|
|
)
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "target was revalidated unchanged")
|
|
if strings.Contains(err.Error(), "partial or indeterminate") {
|
|
t.Fatalf("stable failure was classified as indeterminate: %v", err)
|
|
}
|
|
fixture.assertSnapshot(t, before)
|
|
})
|
|
|
|
t.Run("moved target is partial or indeterminate", func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained moving worktree")
|
|
fixture.mergeLaneIntoMain(t)
|
|
branchOID := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane")
|
|
moved := fixture.lane + "-moved"
|
|
hooks := worktreeRemoveHooks{beforeRemove: func() error {
|
|
return runWorktreeRemoveHookGit(
|
|
fixture.repo,
|
|
"worktree",
|
|
"move",
|
|
"--",
|
|
fixture.lane,
|
|
moved,
|
|
)
|
|
}}
|
|
|
|
err := runWorktreeRemoveGitAdapter(
|
|
t,
|
|
fixture.repo,
|
|
fixture.lane,
|
|
false,
|
|
"main",
|
|
hooks,
|
|
)
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "partial or indeterminate")
|
|
if !strings.Contains(err.Error(), "registered=false, path_exists=false") {
|
|
t.Fatalf("partial failure omitted observed state: %v", err)
|
|
}
|
|
if !fixture.registered(t, moved) {
|
|
t.Fatal("moved worktree is no longer registered")
|
|
}
|
|
if _, statErr := os.Stat(moved); statErr != nil {
|
|
t.Fatalf("moved worktree did not survive: %v", statErr)
|
|
}
|
|
if _, statErr := os.Stat(fixture.lane); !os.IsNotExist(statErr) {
|
|
t.Fatalf("old worktree path still exists: %v", statErr)
|
|
}
|
|
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane"); got != branchOID {
|
|
t.Fatalf("target branch changed: got %s, want %s", got, branchOID)
|
|
}
|
|
if got := fixture.readGitignore(t); !strings.Contains(got, "lane/") {
|
|
t.Fatalf("failed removal cleaned managed ignore entry: %q", got)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterRevalidatesFilesystemAndGitState(t *testing.T) {
|
|
tests := []struct {
|
|
name, want string
|
|
setup func(*testing.T, *worktreeRemovalFixture) worktreeRemoveHooks
|
|
}{
|
|
{"symlink replacement", "target path is not a real directory", func(t *testing.T, f *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error {
|
|
if err := os.Rename(f.lane, f.lane+"-original"); err != nil {
|
|
return err
|
|
}
|
|
return os.Symlink(f.lane+"-original", f.lane)
|
|
}}
|
|
}},
|
|
{"HEAD", "target HEAD changed", func(t *testing.T, f *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error { return runWorktreeRemoveHookGit(f.lane, "commit", "--allow-empty", "-m", "interleaved") }}
|
|
}},
|
|
{"cleanliness", "target cleanliness changed", func(t *testing.T, f *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error {
|
|
return os.WriteFile(filepath.Join(f.lane, "interleaved.txt"), []byte("changed\n"), 0644)
|
|
}}
|
|
}},
|
|
{"dirty content", "target changed files changed", func(t *testing.T, f *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
f.writeLaneFile(t, "dirty.txt", "alpha\n")
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error { return os.WriteFile(filepath.Join(f.lane, "dirty.txt"), []byte("bravo\n"), 0644) }}
|
|
}},
|
|
{"comparator", "comparison target changed", func(t *testing.T, f *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error { return runWorktreeRemoveHookGit(f.repo, "reset", "--hard", f.baseOID) }}
|
|
}},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
if test.name != "dirty content" {
|
|
fixture.commitLane(t, "contained")
|
|
fixture.mergeLaneIntoMain(t)
|
|
}
|
|
hooks := test.setup(t, fixture)
|
|
force := test.name == "dirty content"
|
|
comparator := "main"
|
|
if force {
|
|
comparator = ""
|
|
}
|
|
err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, force, comparator, hooks)
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, test.want)
|
|
if !fixture.registered(t, fixture.lane) {
|
|
t.Fatal("target was removed after revalidation failure")
|
|
}
|
|
if test.name == "dirty content" {
|
|
contents, readErr := os.ReadFile(filepath.Join(fixture.lane, "dirty.txt"))
|
|
if readErr != nil {
|
|
t.Fatalf("read interleaved dirty file after refusal: %v", readErr)
|
|
}
|
|
if got, want := string(contents), "bravo\n"; got != want {
|
|
t.Fatalf("interleaved dirty file after refusal = %q, want %q", got, want)
|
|
}
|
|
}
|
|
if test.name == "symlink replacement" {
|
|
replacement, statErr := os.Lstat(fixture.lane)
|
|
if statErr != nil {
|
|
t.Fatalf("inspect replacement path: %v", statErr)
|
|
}
|
|
if replacement.Mode()&os.ModeSymlink == 0 {
|
|
t.Fatalf("replacement path mode = %s, want symlink", replacement.Mode())
|
|
}
|
|
original, statErr := os.Stat(fixture.lane + "-original")
|
|
if statErr != nil {
|
|
t.Fatalf("inspect original target directory: %v", statErr)
|
|
}
|
|
if !original.IsDir() {
|
|
t.Fatalf("original target mode = %s, want directory", original.Mode())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterRevalidatesLockStateInBothDirections(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name string
|
|
before func(*testing.T, *worktreeRemovalFixture) worktreeRemovalSnapshot
|
|
hook func(*worktreeRemovalFixture) worktreeRemoveHooks
|
|
}{
|
|
{
|
|
name: "locked to unlocked",
|
|
before: func(t *testing.T, fixture *worktreeRemovalFixture) worktreeRemovalSnapshot {
|
|
want := fixture.snapshot(t)
|
|
fixture.git(t, fixture.repo, "worktree", "lock", fixture.lane)
|
|
return want
|
|
},
|
|
hook: func(fixture *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error {
|
|
return runWorktreeRemoveHookGit(fixture.repo, "worktree", "unlock", "--", fixture.lane)
|
|
}}
|
|
},
|
|
},
|
|
{
|
|
name: "unlocked to locked",
|
|
before: func(t *testing.T, fixture *worktreeRemovalFixture) worktreeRemovalSnapshot {
|
|
fixture.git(t, fixture.repo, "worktree", "lock", fixture.lane)
|
|
want := fixture.snapshot(t)
|
|
fixture.git(t, fixture.repo, "worktree", "unlock", fixture.lane)
|
|
return want
|
|
},
|
|
hook: func(fixture *worktreeRemovalFixture) worktreeRemoveHooks {
|
|
return worktreeRemoveHooks{beforeFinalCheck: func() error {
|
|
return runWorktreeRemoveHookGit(fixture.repo, "worktree", "lock", "--", fixture.lane)
|
|
}}
|
|
},
|
|
},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
want := test.before(t, fixture)
|
|
err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "main", test.hook(fixture))
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "registered target identity changed")
|
|
fixture.assertSnapshot(t, want)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestWorktreeRemoveGitAdapterRejectsUnsafeGitignore(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name string
|
|
makeUnsafe func(*testing.T, string) func()
|
|
}{
|
|
{"directory", func(t *testing.T, path string) func() {
|
|
if err := os.Remove(path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Mkdir(path, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return func() {
|
|
info, err := os.Lstat(path)
|
|
if err != nil {
|
|
t.Fatalf("inspect unsafe .gitignore directory: %v", err)
|
|
}
|
|
if !info.IsDir() {
|
|
t.Fatalf("unsafe .gitignore mode = %s, want directory", info.Mode())
|
|
}
|
|
}
|
|
}},
|
|
{"symlink", func(t *testing.T, path string) func() {
|
|
external := filepath.Join(t.TempDir(), "external")
|
|
externalContent := []byte("external sentinel\n")
|
|
if err := os.WriteFile(external, externalContent, 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Remove(path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(external, path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return func() {
|
|
info, err := os.Lstat(path)
|
|
if err != nil {
|
|
t.Fatalf("inspect unsafe .gitignore symlink: %v", err)
|
|
}
|
|
if info.Mode()&os.ModeSymlink == 0 {
|
|
t.Fatalf("unsafe .gitignore mode = %s, want symlink", info.Mode())
|
|
}
|
|
content, err := os.ReadFile(external)
|
|
if err != nil {
|
|
t.Fatalf("read external sentinel: %v", err)
|
|
}
|
|
if !bytes.Equal(content, externalContent) {
|
|
t.Fatalf("external symlink target changed: %q", content)
|
|
}
|
|
}
|
|
}},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
fixture := newWorktreeRemovalFixture(t)
|
|
fixture.commitLane(t, "contained")
|
|
fixture.mergeLaneIntoMain(t)
|
|
beforeRegistry := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z")
|
|
beforeHead := fixture.git(t, fixture.lane, "rev-parse", "HEAD")
|
|
beforeBranch := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane")
|
|
beforeStatus := fixture.git(t, fixture.lane, "status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching")
|
|
verifyUnsafe := test.makeUnsafe(t, filepath.Join(fixture.repo, ".gitignore"))
|
|
err := runWorktreeRemoveGitAdapter(t, fixture.repo, fixture.lane, false, "main", worktreeRemoveHooks{})
|
|
requireWorktreeRemoveGitAdapterFailure(t, err, "is not a regular file")
|
|
if !fixture.registered(t, fixture.lane) {
|
|
t.Fatal("unsafe .gitignore removed target")
|
|
}
|
|
if got := fixture.git(t, fixture.repo, "worktree", "list", "--porcelain", "-z"); got != beforeRegistry {
|
|
t.Fatalf("unsafe .gitignore refusal changed registry\ngot: %q\nwant: %q", got, beforeRegistry)
|
|
}
|
|
if got := fixture.git(t, fixture.lane, "rev-parse", "HEAD"); got != beforeHead {
|
|
t.Fatalf("unsafe .gitignore refusal changed HEAD: got %s, want %s", got, beforeHead)
|
|
}
|
|
if got := fixture.git(t, fixture.repo, "rev-parse", "refs/heads/lane"); got != beforeBranch {
|
|
t.Fatalf("unsafe .gitignore refusal changed branch: got %s, want %s", got, beforeBranch)
|
|
}
|
|
if got := fixture.git(t, fixture.lane, "status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching"); got != beforeStatus {
|
|
t.Fatalf("unsafe .gitignore refusal changed target status: got %q, want %q", got, beforeStatus)
|
|
}
|
|
verifyUnsafe()
|
|
})
|
|
}
|
|
}
|