The real-GNU-timeout and real-Perl-alarm expiry subtests stand in a bd that never returns with a bare `while :; do :; done`. On a normal run the helper reaps it at 1s. When the go test process is killed mid-subtest, though, the helper has already setpgid()d itself and the stub out of the harness's group, the tree-kill reaches the helper by pid before its child, and the orphan is reparented to 1 and spins at 100% CPU forever: one such stub was found 2.5h old on a shared build box after a session teardown. The stub now paces itself with sleep and exits 97 on its own after 60 ticks, so a killed run leaks at most a minute of idle sleep. The generated hook runs under a controlled PATH that carries only the fixtures and the helper under test, so the test resolves sleep once (findHookProcessSleep, the same shape as the Perl probe) and hands it to the stub as HOOK_TEST_SLEEP by absolute path. The sleep's stdio is detached because Perl's alarm signals only the exec'd stub, not a group, and the orphaned sleep must not hold the test's output pipe open past exec.Cmd.WaitDelay. Exit 97 is outside every status the hook normalizes, so a stub that outlives the helper still fails the expiry assertions loudly. Tests: go test ./cmd/bd -run TestGeneratedHookTimeoutProcessBoundary -count=1 (twice, darwin/arm64, bash 5 + coreutils gtimeout + perl); go vet ./cmd/bd. Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
783 lines
27 KiB
Go
783 lines
27 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
const hookProcessBDStub = `#!/bin/sh
|
|
printf 'bd-argc=%s\n' "$#"
|
|
_bd_test_index=0
|
|
for _bd_test_arg
|
|
do
|
|
printf 'bd-arg-%s=<%s>\n' "$_bd_test_index" "$_bd_test_arg"
|
|
_bd_test_index=$((_bd_test_index + 1))
|
|
done
|
|
exit "${HOOK_TEST_BD_EXIT:-0}"
|
|
`
|
|
|
|
// hookProcessLongRunningBDStub stands in for a bd that never returns, so the
|
|
// expiry subtests can prove the timeout helper reaps it. It sleeps instead of
|
|
// busy-looping and bounds itself: when a test run is killed before the helper
|
|
// fires (the harness reaches the helper by pid before its child), the orphan
|
|
// idles for at most a minute and exits on its own instead of spinning at 100%
|
|
// CPU forever with ppid 1. Exit 97 is outside every code the hook normalizes,
|
|
// so a run that outlives the helper still fails the test. The sleep runs with
|
|
// its stdio detached: when the helper signals only the stub (Perl's alarm hits
|
|
// the exec'd process, not a group), the orphaned sleep must not keep the test's
|
|
// output pipe open past exec.Cmd.WaitDelay.
|
|
const hookProcessLongRunningBDStub = `#!/bin/sh
|
|
printf 'long-running-bd-started\n'
|
|
_bd_test_tick=0
|
|
while [ "$_bd_test_tick" -lt 60 ]; do
|
|
"${HOOK_TEST_SLEEP:?}" 1 </dev/null >/dev/null 2>&1
|
|
_bd_test_tick=$((_bd_test_tick + 1))
|
|
done
|
|
exit 97
|
|
`
|
|
|
|
const hookProcessGNUTimeoutStub = `#!/bin/sh
|
|
if [ "${1-}" = "--version" ]; then
|
|
printf 'timeout (GNU coreutils) 9.99\n'
|
|
exit 0
|
|
fi
|
|
if [ "${1-}" != "--" ] || [ "$#" -lt 6 ]; then
|
|
printf 'invalid-timeout-argv\n' >&2
|
|
exit 96
|
|
fi
|
|
shift
|
|
printf 'helper=timeout\n'
|
|
printf 'duration=<%s>\n' "$1"
|
|
shift
|
|
exec "$@"
|
|
`
|
|
|
|
const hookProcessGNUGtimeoutStub = `#!/bin/sh
|
|
if [ "${1-}" = "--version" ]; then
|
|
printf 'timeout (GNU coreutils) 9.99\n'
|
|
exit 0
|
|
fi
|
|
if [ "${1-}" != "--" ] || [ "$#" -lt 6 ]; then
|
|
printf 'invalid-gtimeout-argv\n' >&2
|
|
exit 96
|
|
fi
|
|
shift
|
|
printf 'helper=gtimeout\n'
|
|
printf 'duration=<%s>\n' "$1"
|
|
shift
|
|
exec "$@"
|
|
`
|
|
|
|
const hookProcessIncompatibleTimeoutStub = `#!/bin/sh
|
|
if [ "${1-}" = "--version" ]; then
|
|
printf 'Microsoft Windows timeout\n'
|
|
exit 1
|
|
fi
|
|
printf 'hostile-timeout-invoked\n' >&2
|
|
exit 97
|
|
`
|
|
|
|
const hookProcessFailedGNUProbeStub = `#!/bin/sh
|
|
if [ "${1-}" = "--version" ]; then
|
|
printf 'timeout (GNU coreutils) 9.99\n'
|
|
exit 23
|
|
fi
|
|
printf 'failed-gnu-probe-invoked\n' >&2
|
|
exit 97
|
|
`
|
|
|
|
const hookProcessIncompatibleGtimeoutStub = `#!/bin/sh
|
|
if [ "${1-}" = "--version" ]; then
|
|
printf 'not GNU coreutils\n'
|
|
exit 0
|
|
fi
|
|
printf 'hostile-gtimeout-invoked\n' >&2
|
|
exit 98
|
|
`
|
|
|
|
const hookProcessPerlStub = `#!/bin/sh
|
|
if [ "${1-}" != "-e" ] || [ "${3-}" != "--" ] || [ "$#" -lt 8 ]; then
|
|
printf 'invalid-perl-argv\n' >&2
|
|
exit 96
|
|
fi
|
|
shift 3
|
|
printf 'helper=perl\n'
|
|
printf 'duration=<%s>\n' "$1"
|
|
shift
|
|
exec "$@"
|
|
`
|
|
|
|
type hookProcessFixture struct {
|
|
name string
|
|
body string
|
|
}
|
|
|
|
type hookProcessCase struct {
|
|
fixtures []hookProcessFixture
|
|
bdBody string
|
|
bdExit int
|
|
shellOption string
|
|
usePOSIXSh bool
|
|
timeout *string
|
|
pathTail string
|
|
sleepPath string
|
|
args []string
|
|
}
|
|
|
|
type hookProcessResult struct {
|
|
output string
|
|
exitCode int
|
|
elapsed time.Duration
|
|
}
|
|
|
|
func TestGeneratedHookTimeoutProcessBoundary(t *testing.T) {
|
|
t.Run("backend selection", testHookProcessBackendSelection)
|
|
t.Run("positive timeout values", testHookProcessTimeoutValidation)
|
|
t.Run("shell options preserve argv and status", testHookProcessShellOptions)
|
|
t.Run("POSIX sh preserves argv and status", testHookProcessPOSIXShell)
|
|
t.Run("reserved statuses are backend scoped", testHookProcessReservedStatuses)
|
|
t.Run("real coreutils timeout expires a responsive child", testHookProcessRealTimeoutExpiry)
|
|
t.Run("real Perl alarm expires a responsive child", testHookProcessRealPerlExpiry)
|
|
t.Run("Windows checkout rejects System32 timeout", testHookProcessWindowsSystemTimeoutCheckout)
|
|
}
|
|
|
|
func testHookProcessBackendSelection(t *testing.T) {
|
|
// Derive the uutils helper from the GNU stub so the two differ only in the
|
|
// banner, but fail loudly if that banner ever moves: strings.Replace returns
|
|
// its input unchanged when the pattern is absent, which would silently turn
|
|
// the uutils case into a second copy of the GNU one.
|
|
const hookProcessGNUTimeoutBanner = "(GNU coreutils) 9.99"
|
|
uutilsTimeoutStub := strings.Replace(hookProcessGNUTimeoutStub, hookProcessGNUTimeoutBanner, "(uutils coreutils) 0.10.0", 1)
|
|
if uutilsTimeoutStub == hookProcessGNUTimeoutStub {
|
|
t.Fatalf("uutils fixture is a copy of the GNU stub: %q not found in hookProcessGNUTimeoutStub", hookProcessGNUTimeoutBanner)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
fixtures []hookProcessFixture
|
|
wantHelper string
|
|
wantWarning bool
|
|
}{
|
|
{
|
|
name: "incompatible timeout yields to gtimeout",
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessIncompatibleTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessGNUGtimeoutStub},
|
|
},
|
|
wantHelper: "helper=gtimeout",
|
|
},
|
|
{
|
|
name: "uutils coreutils timeout is selected like GNU",
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: uutilsTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessGNUGtimeoutStub},
|
|
},
|
|
wantHelper: "helper=timeout",
|
|
},
|
|
{
|
|
name: "nonzero GNU-looking probe yields to gtimeout",
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessFailedGNUProbeStub},
|
|
{name: "gtimeout", body: hookProcessGNUGtimeoutStub},
|
|
},
|
|
wantHelper: "helper=gtimeout",
|
|
},
|
|
{
|
|
name: "Perl follows incompatible timeout commands",
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessIncompatibleTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessIncompatibleGtimeoutStub},
|
|
{name: "perl", body: hookProcessPerlStub},
|
|
},
|
|
wantHelper: "helper=perl",
|
|
},
|
|
{
|
|
name: "direct fallback is explicit",
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessIncompatibleTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessIncompatibleGtimeoutStub},
|
|
},
|
|
wantWarning: true,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
timeout := "17"
|
|
args := []string{"remote with space", "https://example.invalid/repo"}
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
fixtures: tt.fixtures,
|
|
timeout: &timeout,
|
|
args: args,
|
|
})
|
|
if result.exitCode != 0 {
|
|
t.Fatalf("generated hook exit = %d, want 0\n%s", result.exitCode, result.output)
|
|
}
|
|
if tt.wantHelper != "" && !strings.Contains(result.output, tt.wantHelper) {
|
|
t.Errorf("output missing selected helper %q\n%s", tt.wantHelper, result.output)
|
|
}
|
|
if got := strings.Contains(result.output, "running without timeout"); got != tt.wantWarning {
|
|
t.Errorf("direct-fallback warning presence = %v, want %v\n%s", got, tt.wantWarning, result.output)
|
|
}
|
|
for _, forbidden := range []string{
|
|
"hostile-timeout-invoked", "failed-gnu-probe-invoked", "hostile-gtimeout-invoked",
|
|
} {
|
|
if strings.Contains(result.output, forbidden) {
|
|
t.Errorf("incompatible helper was invoked: %s\n%s", forbidden, result.output)
|
|
}
|
|
}
|
|
assertHookProcessBDInvocation(t, result.output, "pre-push", args...)
|
|
})
|
|
}
|
|
}
|
|
|
|
func testHookProcessTimeoutValidation(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value *string
|
|
wantSeconds string
|
|
wantWarning bool
|
|
}{
|
|
{name: "unset uses default", wantSeconds: strconv.Itoa(hookTimeoutSeconds)},
|
|
{name: "option-looking value", value: hookProcessString("--help"), wantSeconds: strconv.Itoa(hookTimeoutSeconds), wantWarning: true},
|
|
{name: "zero", value: hookProcessString("0"), wantSeconds: strconv.Itoa(hookTimeoutSeconds), wantWarning: true},
|
|
{name: "all-zero digits", value: hookProcessString("000"), wantSeconds: strconv.Itoa(hookTimeoutSeconds), wantWarning: true},
|
|
{name: "mixed value", value: hookProcessString("12s"), wantSeconds: strconv.Itoa(hookTimeoutSeconds), wantWarning: true},
|
|
{name: "positive whole seconds", value: hookProcessString("17"), wantSeconds: "17"},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
fixtures: []hookProcessFixture{{name: "timeout", body: hookProcessGNUTimeoutStub}},
|
|
timeout: tt.value,
|
|
})
|
|
if result.exitCode != 0 {
|
|
t.Fatalf("generated hook exit = %d, want 0\n%s", result.exitCode, result.output)
|
|
}
|
|
if marker := "duration=<" + tt.wantSeconds + ">"; !strings.Contains(result.output, marker) {
|
|
t.Errorf("output missing effective timeout %q\n%s", marker, result.output)
|
|
}
|
|
if got := strings.Contains(result.output, "invalid BEADS_HOOK_TIMEOUT"); got != tt.wantWarning {
|
|
t.Errorf("invalid-timeout warning presence = %v, want %v\n%s", got, tt.wantWarning, result.output)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func testHookProcessShellOptions(t *testing.T) {
|
|
const wantExit = 37
|
|
args := []string{"argument with space", "second-argument"}
|
|
for _, option := range []string{"", "e", "u", "eu"} {
|
|
name := option
|
|
if name == "" {
|
|
name = "default"
|
|
}
|
|
t.Run("set-"+name, func(t *testing.T) {
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
fixtures: []hookProcessFixture{{name: "timeout", body: hookProcessGNUTimeoutStub}},
|
|
bdExit: wantExit,
|
|
shellOption: option,
|
|
args: args,
|
|
})
|
|
if result.exitCode != wantExit {
|
|
t.Fatalf("generated hook exit = %d, want bd exit %d\n%s", result.exitCode, wantExit, result.output)
|
|
}
|
|
assertHookProcessBDInvocation(t, result.output, "pre-push", args...)
|
|
})
|
|
}
|
|
}
|
|
|
|
func testHookProcessPOSIXShell(t *testing.T) {
|
|
const wantExit = 37
|
|
args := []string{"argument with space", "second-argument"}
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
fixtures: []hookProcessFixture{{name: "timeout", body: hookProcessGNUTimeoutStub}},
|
|
bdExit: wantExit,
|
|
shellOption: "eu",
|
|
usePOSIXSh: true,
|
|
args: args,
|
|
})
|
|
if result.exitCode != wantExit {
|
|
t.Fatalf("generated hook exit = %d, want bd exit %d\n%s", result.exitCode, wantExit, result.output)
|
|
}
|
|
assertHookProcessBDInvocation(t, result.output, "pre-push", args...)
|
|
}
|
|
|
|
func testHookProcessReservedStatuses(t *testing.T) {
|
|
gnu := []hookProcessFixture{{name: "timeout", body: hookProcessGNUTimeoutStub}}
|
|
perl := []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessIncompatibleTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessIncompatibleGtimeoutStub},
|
|
{name: "perl", body: hookProcessPerlStub},
|
|
}
|
|
direct := perl[:2]
|
|
tests := []struct {
|
|
name string
|
|
fixtures []hookProcessFixture
|
|
bdExit int
|
|
wantExit int
|
|
wantWarning bool
|
|
wantDBWarning bool
|
|
}{
|
|
{name: "database-not-initialized is skipped", fixtures: gnu, bdExit: 3, wantDBWarning: true},
|
|
{name: "GNU owns 124", fixtures: gnu, bdExit: 124, wantWarning: true},
|
|
{name: "GNU preserves 137", fixtures: gnu, bdExit: 137, wantExit: 137},
|
|
{name: "GNU preserves 142", fixtures: gnu, bdExit: 142, wantExit: 142},
|
|
{name: "Perl preserves 124", fixtures: perl, bdExit: 124, wantExit: 124},
|
|
{name: "Perl owns 142", fixtures: perl, bdExit: 142, wantWarning: true},
|
|
{name: "direct preserves 124", fixtures: direct, bdExit: 124, wantExit: 124},
|
|
{name: "direct preserves 137", fixtures: direct, bdExit: 137, wantExit: 137},
|
|
{name: "direct preserves 142", fixtures: direct, bdExit: 142, wantExit: 142},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
result := runGeneratedHookProcess(t, hookProcessCase{fixtures: tt.fixtures, bdExit: tt.bdExit})
|
|
if result.exitCode != tt.wantExit {
|
|
t.Errorf("generated hook exit = %d, want %d\n%s", result.exitCode, tt.wantExit, result.output)
|
|
}
|
|
if got := strings.Contains(result.output, "timed out after"); got != tt.wantWarning {
|
|
t.Errorf("timeout warning presence = %v, want %v\n%s", got, tt.wantWarning, result.output)
|
|
}
|
|
if got := strings.Contains(result.output, "database not initialized"); got != tt.wantDBWarning {
|
|
t.Errorf("database warning presence = %v, want %v\n%s", got, tt.wantDBWarning, result.output)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func testHookProcessRealTimeoutExpiry(t *testing.T) {
|
|
helperName, helperDir := findHookProcessCoreutilsTimeout(t)
|
|
timeout := "1"
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
bdBody: hookProcessLongRunningBDStub,
|
|
timeout: &timeout,
|
|
pathTail: helperDir,
|
|
sleepPath: findHookProcessSleep(t),
|
|
})
|
|
if result.exitCode != 0 {
|
|
t.Fatalf("generated hook exit = %d, want normalized timeout success\n%s", result.exitCode, result.output)
|
|
}
|
|
if !strings.Contains(result.output, "long-running-bd-started") || !strings.Contains(result.output, "timed out after 1s") {
|
|
t.Fatalf("%s did not expire and normalize the responsive child\n%s", helperName, result.output)
|
|
}
|
|
maxElapsed := 9 * time.Second
|
|
if result.elapsed > maxElapsed {
|
|
t.Errorf("%s expiry took %s, want at most %s", helperName, result.elapsed, maxElapsed)
|
|
}
|
|
}
|
|
|
|
func testHookProcessRealPerlExpiry(t *testing.T) {
|
|
if runtime.GOOS == "windows" {
|
|
t.Skip("Git for Windows Perl does not reliably preserve alarm across exec; GNU timeout is the normal Git Bash backend")
|
|
}
|
|
perlDir := findHookProcessPerl(t)
|
|
timeout := "1"
|
|
result := runGeneratedHookProcess(t, hookProcessCase{
|
|
fixtures: []hookProcessFixture{
|
|
{name: "timeout", body: hookProcessIncompatibleTimeoutStub},
|
|
{name: "gtimeout", body: hookProcessIncompatibleGtimeoutStub},
|
|
},
|
|
bdBody: hookProcessLongRunningBDStub,
|
|
timeout: &timeout,
|
|
pathTail: perlDir,
|
|
sleepPath: findHookProcessSleep(t),
|
|
})
|
|
if result.exitCode != 0 {
|
|
t.Fatalf("generated hook exit = %d, want normalized Perl alarm success\n%s", result.exitCode, result.output)
|
|
}
|
|
if !strings.Contains(result.output, "long-running-bd-started") || !strings.Contains(result.output, "timed out after 1s") {
|
|
t.Fatalf("real Perl did not expire and normalize the responsive child\n%s", result.output)
|
|
}
|
|
if result.elapsed > 9*time.Second {
|
|
t.Errorf("Perl expiry took %s, want at most 9s", result.elapsed)
|
|
}
|
|
}
|
|
|
|
func testHookProcessWindowsSystemTimeoutCheckout(t *testing.T) {
|
|
if runtime.GOOS != "windows" {
|
|
t.Skip("the System32 timeout boundary is Windows-specific")
|
|
}
|
|
|
|
systemRoot := os.Getenv("SystemRoot")
|
|
if systemRoot == "" {
|
|
t.Fatal("SystemRoot is required for the System32 timeout boundary")
|
|
}
|
|
system32 := filepath.Join(systemRoot, "System32")
|
|
systemTimeout := filepath.Join(system32, "timeout.exe")
|
|
if _, err := os.Stat(systemTimeout); err != nil {
|
|
t.Fatalf("System32 timeout.exe is required: %v", err)
|
|
}
|
|
|
|
binDir := t.TempDir()
|
|
writeHookProcessFixture(t, binDir, "bd", hookProcessBDStub)
|
|
controlledPath := hookProcessShellPath(t, binDir) + ":" + hookProcessShellPath(t, system32)
|
|
probe := exec.Command(hookProcessShell(t), "--noprofile", "--norc", "-c", `
|
|
PATH=$1
|
|
export PATH
|
|
_bd_test_timeout=$(command -v timeout) || exit 1
|
|
printf '%s\n' "$_bd_test_timeout"
|
|
if timeout --version >/dev/null 2>&1; then exit 2; fi
|
|
`, "system32-timeout-probe", controlledPath)
|
|
probe.Env = hookProcessEnv()
|
|
probeOutput, err := probe.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("exercise System32 timeout through the hook PATH: %v\n%s", err, string(probeOutput))
|
|
}
|
|
gotTimeout := strings.TrimSuffix(strings.ToLower(strings.TrimSpace(string(probeOutput))), ".exe")
|
|
wantTimeout := strings.TrimSuffix(strings.ToLower(hookProcessShellPath(t, systemTimeout)), ".exe")
|
|
if gotTimeout != wantTimeout {
|
|
t.Fatalf("hook PATH resolved timeout to %q, want System32 %q", gotTimeout, wantTimeout)
|
|
}
|
|
|
|
repoDir := filepath.Join(t.TempDir(), "repo")
|
|
if err := os.MkdirAll(repoDir, 0o755); err != nil {
|
|
t.Fatalf("create temporary repository: %v", err)
|
|
}
|
|
gitPath, err := exec.LookPath("git.exe")
|
|
if err != nil {
|
|
t.Fatalf("Git for Windows is required: %v", err)
|
|
}
|
|
gitEnv := hookProcessGitEnv(t.TempDir(), "HOOK_TEST_BD_EXIT=0")
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "init", "--initial-branch=main", ".")
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "config", "core.hooksPath", ".git/hooks")
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "config", "user.name", "Hook Test")
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "config", "user.email", "hook-test@example.invalid")
|
|
if err := os.WriteFile(filepath.Join(repoDir, "tracked.txt"), []byte("initial\n"), 0o600); err != nil {
|
|
t.Fatalf("write tracked fixture: %v", err)
|
|
}
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "add", "--", "tracked.txt")
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "commit", "--no-verify", "-m", "initial")
|
|
commit := strings.TrimSpace(runHookProcessGit(t, gitPath, repoDir, gitEnv, "rev-parse", "HEAD"))
|
|
runHookProcessGit(t, gitPath, repoDir, gitEnv, "branch", "topic")
|
|
if head := strings.TrimSpace(runHookProcessGit(t, gitPath, repoDir, gitEnv, "symbolic-ref", "--short", "HEAD")); head != "main" {
|
|
t.Fatalf("HEAD = %q before checkout, want main", head)
|
|
}
|
|
|
|
hookBody := "#!/bin/sh\nPATH=" + hookProcessShellQuote(controlledPath) + "\nexport PATH\n" + generateHookSection("post-checkout")
|
|
writeHookProcessFixture(t, filepath.Join(repoDir, ".git", "hooks"), "post-checkout", hookBody)
|
|
checkout := exec.Command(gitPath, "checkout", "topic")
|
|
checkout.Dir = repoDir
|
|
checkout.Env = gitEnv
|
|
checkoutOutput, err := checkout.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("checkout reported generated-hook failure: %v\n%s", err, string(checkoutOutput))
|
|
}
|
|
output := string(checkoutOutput)
|
|
if !strings.Contains(output, "running without timeout") {
|
|
t.Errorf("checkout output missing incompatible-timeout fallback warning\n%s", output)
|
|
}
|
|
assertHookProcessBDInvocation(t, output, "post-checkout", commit, commit, "1")
|
|
if head := strings.TrimSpace(runHookProcessGit(t, gitPath, repoDir, gitEnv, "symbolic-ref", "--short", "HEAD")); head != "topic" {
|
|
t.Fatalf("HEAD = %q after successful checkout, want topic", head)
|
|
}
|
|
}
|
|
|
|
func runGeneratedHookProcess(t *testing.T, tc hookProcessCase) hookProcessResult {
|
|
t.Helper()
|
|
|
|
binDir := t.TempDir()
|
|
bdBody := tc.bdBody
|
|
if bdBody == "" {
|
|
bdBody = hookProcessBDStub
|
|
}
|
|
writeHookProcessFixture(t, binDir, "bd", bdBody)
|
|
for _, fixture := range tc.fixtures {
|
|
writeHookProcessFixture(t, binDir, fixture.name, fixture.body)
|
|
}
|
|
|
|
hookPath := filepath.Join(t.TempDir(), "pre-push")
|
|
writeHookProcessFixture(t, filepath.Dir(hookPath), filepath.Base(hookPath), "#!/bin/sh\n"+generateHookSection("pre-push"))
|
|
controlledPath := hookProcessShellPath(t, binDir)
|
|
if tc.pathTail != "" {
|
|
controlledPath += ":" + tc.pathTail
|
|
}
|
|
|
|
controlScript := `PATH=$1
|
|
export PATH
|
|
shift
|
|
case "$1" in
|
|
"") ;;
|
|
e) set -e ;;
|
|
u) set -u ;;
|
|
eu) set -eu ;;
|
|
*) exit 95 ;;
|
|
esac
|
|
shift
|
|
_bd_test_hook=$1
|
|
shift
|
|
. "$_bd_test_hook"
|
|
`
|
|
shellPath := hookProcessShell(t)
|
|
commandArgs := []string{"--noprofile", "--norc", "-c", controlScript, "generated-hook-test", controlledPath, tc.shellOption, hookProcessShellPath(t, hookPath)}
|
|
if tc.usePOSIXSh {
|
|
shellPath = hookProcessPOSIXShell(t)
|
|
commandArgs = []string{"-c", controlScript, "generated-hook-test", controlledPath, tc.shellOption, hookProcessShellPath(t, hookPath)}
|
|
}
|
|
commandArgs = append(commandArgs, tc.args...)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
t.Cleanup(cancel)
|
|
cmd := exec.CommandContext(ctx, shellPath, commandArgs...)
|
|
cmd.WaitDelay = time.Second
|
|
cmd.Env = append(hookProcessEnv(), "HOOK_TEST_BD_EXIT="+strconv.Itoa(tc.bdExit))
|
|
if tc.timeout != nil {
|
|
cmd.Env = append(cmd.Env, "BEADS_HOOK_TIMEOUT="+*tc.timeout)
|
|
}
|
|
if tc.sleepPath != "" {
|
|
cmd.Env = append(cmd.Env, "HOOK_TEST_SLEEP="+tc.sleepPath)
|
|
}
|
|
started := time.Now()
|
|
output, err := cmd.CombinedOutput()
|
|
elapsed := time.Since(started)
|
|
if ctx.Err() != nil {
|
|
t.Fatalf("generated hook exceeded process-test deadline: %v\n%s", ctx.Err(), string(output))
|
|
}
|
|
exitCode := 0
|
|
if err != nil {
|
|
exitErr, ok := err.(*exec.ExitError)
|
|
if !ok {
|
|
t.Fatalf("run generated hook: %v\n%s", err, string(output))
|
|
}
|
|
exitCode = exitErr.ExitCode()
|
|
}
|
|
return hookProcessResult{output: string(output), exitCode: exitCode, elapsed: elapsed}
|
|
}
|
|
|
|
// findHookProcessCoreutilsTimeout mirrors the generated shim's identity
|
|
// allowlist (cmd/bd/hooks.go generateHookSection). Keep the `case` here in step
|
|
// with the one the generator emits: this is the second copy of that contract,
|
|
// and a narrower copy silently skips the only test that drives a real timeout
|
|
// binary on exactly the hosts the wider allowlist exists for.
|
|
func findHookProcessCoreutilsTimeout(t *testing.T) (string, string) {
|
|
t.Helper()
|
|
probe := `for _bd_test_candidate in timeout gtimeout; do
|
|
if command -v "$_bd_test_candidate" >/dev/null 2>&1 &&
|
|
_bd_test_version="$("$_bd_test_candidate" --version 2>/dev/null)"; then
|
|
case "$_bd_test_version" in
|
|
"timeout (GNU coreutils) "*|"timeout (uutils coreutils) "*)
|
|
_bd_test_path=$(command -v "$_bd_test_candidate")
|
|
printf '%s\n%s\n' "$_bd_test_candidate" "${_bd_test_path%/*}"
|
|
exit 0
|
|
;;
|
|
esac
|
|
fi
|
|
done
|
|
exit 1
|
|
`
|
|
cmd := exec.Command(hookProcessShell(t), "--noprofile", "--norc", "-c", probe)
|
|
cmd.Env = hookProcessEnv()
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Skipf("no compatible coreutils timeout is available: %s", strings.TrimSpace(string(output)))
|
|
}
|
|
lines := strings.Split(strings.TrimSpace(string(output)), "\n")
|
|
if len(lines) != 2 || lines[0] == "" || lines[1] == "" {
|
|
t.Fatalf("unexpected coreutils timeout probe output: %q", string(output))
|
|
}
|
|
return lines[0], lines[1]
|
|
}
|
|
|
|
func findHookProcessPerl(t *testing.T) string {
|
|
t.Helper()
|
|
probe := `
|
|
_bd_test_path=$(command -v perl) || exit 1
|
|
perl -e 'exit 0' || exit 1
|
|
printf '%s\n' "${_bd_test_path%/*}"
|
|
`
|
|
cmd := exec.Command(hookProcessShell(t), "--noprofile", "--norc", "-c", probe)
|
|
cmd.Env = hookProcessEnv()
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Skipf("Perl is unavailable: %s", strings.TrimSpace(string(output)))
|
|
}
|
|
dir := strings.TrimSpace(string(output))
|
|
if dir == "" {
|
|
t.Fatalf("unexpected Perl probe output: %q", string(output))
|
|
}
|
|
return dir
|
|
}
|
|
|
|
// findHookProcessSleep resolves the sleep the long-running bd stub paces itself
|
|
// with. The generated hook runs under a controlled PATH that carries only the
|
|
// fixtures and the helper under test, so the stub is handed sleep by absolute
|
|
// path (in the shell's own spelling, which on Git Bash is the MSYS form).
|
|
func findHookProcessSleep(t *testing.T) string {
|
|
t.Helper()
|
|
probe := `
|
|
_bd_test_path=$(command -v sleep) || exit 1
|
|
"$_bd_test_path" 0 || exit 1
|
|
printf '%s\n' "$_bd_test_path"
|
|
`
|
|
cmd := exec.Command(hookProcessShell(t), "--noprofile", "--norc", "-c", probe)
|
|
cmd.Env = hookProcessEnv()
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("sleep is required to pace the long-running bd stub: %s", strings.TrimSpace(string(output)))
|
|
}
|
|
path := strings.TrimSpace(string(output))
|
|
if path == "" {
|
|
t.Fatalf("unexpected sleep probe output: %q", string(output))
|
|
}
|
|
return path
|
|
}
|
|
|
|
func writeHookProcessFixture(t *testing.T, dir, name, body string) {
|
|
t.Helper()
|
|
path := filepath.Join(dir, name)
|
|
if err := os.WriteFile(path, []byte(body), 0o755); err != nil {
|
|
t.Fatalf("write %s fixture: %v", name, err)
|
|
}
|
|
if err := os.Chmod(path, 0o755); err != nil {
|
|
t.Fatalf("make %s fixture executable: %v", name, err)
|
|
}
|
|
}
|
|
|
|
func assertHookProcessBDInvocation(t *testing.T, output, hookName string, hookArgs ...string) {
|
|
t.Helper()
|
|
wantArgs := append([]string{"hooks", "run", hookName}, hookArgs...)
|
|
if marker := fmt.Sprintf("bd-argc=%d", len(wantArgs)); !strings.Contains(output, marker) {
|
|
t.Errorf("output missing %q\n%s", marker, output)
|
|
}
|
|
for index, arg := range wantArgs {
|
|
marker := fmt.Sprintf("bd-arg-%d=<%s>", index, arg)
|
|
if !strings.Contains(output, marker) {
|
|
t.Errorf("output missing argument marker %q\n%s", marker, output)
|
|
}
|
|
}
|
|
}
|
|
|
|
func hookProcessShell(t *testing.T) string {
|
|
t.Helper()
|
|
if runtime.GOOS == "windows" {
|
|
gitPath, err := exec.LookPath("git.exe")
|
|
if err != nil {
|
|
t.Fatalf("Git for Windows is required to locate Git Bash: %v", err)
|
|
}
|
|
dir := filepath.Dir(gitPath)
|
|
for range 5 {
|
|
for _, candidate := range []string{filepath.Join(dir, "bash.exe"), filepath.Join(dir, "bin", "bash.exe")} {
|
|
if info, statErr := os.Stat(candidate); statErr == nil && !info.IsDir() {
|
|
return candidate
|
|
}
|
|
}
|
|
parent := filepath.Dir(dir)
|
|
if parent == dir {
|
|
break
|
|
}
|
|
dir = parent
|
|
}
|
|
t.Fatalf("could not locate Git Bash beside %s", gitPath)
|
|
}
|
|
shell, err := exec.LookPath("bash")
|
|
if err != nil {
|
|
t.Fatalf("Bash is required to exercise generated hooks: %v", err)
|
|
}
|
|
return shell
|
|
}
|
|
|
|
func hookProcessPOSIXShell(t *testing.T) string {
|
|
t.Helper()
|
|
if runtime.GOOS == "windows" {
|
|
bashPath := hookProcessShell(t)
|
|
gitRoot := filepath.Dir(filepath.Dir(bashPath))
|
|
candidate := filepath.Join(gitRoot, "usr", "bin", "sh.exe")
|
|
if info, err := os.Stat(candidate); err == nil && !info.IsDir() {
|
|
return candidate
|
|
}
|
|
t.Fatalf("could not locate Git for Windows POSIX sh beside %s", bashPath)
|
|
}
|
|
shell, err := exec.LookPath("sh")
|
|
if err != nil {
|
|
t.Fatalf("POSIX sh is required to exercise generated hooks: %v", err)
|
|
}
|
|
return shell
|
|
}
|
|
|
|
func hookProcessShellPath(t *testing.T, path string) string {
|
|
t.Helper()
|
|
absolute, err := filepath.Abs(path)
|
|
if err != nil {
|
|
t.Fatalf("resolve shell path %s: %v", path, err)
|
|
}
|
|
if runtime.GOOS != "windows" {
|
|
return filepath.ToSlash(absolute)
|
|
}
|
|
volume := filepath.VolumeName(absolute)
|
|
if len(volume) != 2 || volume[1] != ':' {
|
|
t.Fatalf("Git Bash fixture path must use a drive-letter volume: %q", absolute)
|
|
}
|
|
return "/" + strings.ToLower(volume[:1]) + filepath.ToSlash(absolute[len(volume):])
|
|
}
|
|
|
|
func hookProcessShellQuote(value string) string {
|
|
return "'" + strings.ReplaceAll(value, "'", `'"'"'`) + "'"
|
|
}
|
|
|
|
func hookProcessEnv() []string {
|
|
env := make([]string, 0, len(os.Environ())+2)
|
|
for _, entry := range os.Environ() {
|
|
key, _, ok := strings.Cut(entry, "=")
|
|
if !ok {
|
|
continue
|
|
}
|
|
upper := strings.ToUpper(key)
|
|
if upper == "BASH_ENV" || upper == "BASHOPTS" || upper == "ENV" || upper == "SHELLOPTS" ||
|
|
upper == "BEADS_HOOK_TIMEOUT" || upper == "HOOK_TEST_BD_EXIT" || upper == "HOOK_TEST_SLEEP" {
|
|
continue
|
|
}
|
|
env = append(env, entry)
|
|
}
|
|
return append(env, "BASH_ENV=", "ENV=")
|
|
}
|
|
|
|
func hookProcessGitEnv(home string, extra ...string) []string {
|
|
env := make([]string, 0, len(os.Environ())+8+len(extra))
|
|
for _, entry := range os.Environ() {
|
|
key, _, ok := strings.Cut(entry, "=")
|
|
if !ok {
|
|
continue
|
|
}
|
|
upper := strings.ToUpper(key)
|
|
if upper == "HOME" || upper == "USERPROFILE" || upper == "BASH_ENV" || upper == "BASHOPTS" || upper == "ENV" || upper == "SHELLOPTS" ||
|
|
strings.HasPrefix(upper, "GIT_") || upper == "HOOK_TEST_BD_EXIT" {
|
|
continue
|
|
}
|
|
env = append(env, entry)
|
|
}
|
|
env = append(env,
|
|
"HOME="+home,
|
|
"USERPROFILE="+home,
|
|
"BASH_ENV=",
|
|
"ENV=",
|
|
"GIT_CONFIG_NOSYSTEM=1",
|
|
"GIT_CONFIG_GLOBAL="+os.DevNull,
|
|
"GIT_CONFIG_SYSTEM="+os.DevNull,
|
|
"GIT_TERMINAL_PROMPT=0",
|
|
)
|
|
return append(env, extra...)
|
|
}
|
|
|
|
func runHookProcessGit(t *testing.T, gitPath, dir string, env []string, args ...string) string {
|
|
t.Helper()
|
|
cmd := exec.Command(gitPath, args...)
|
|
cmd.Dir = dir
|
|
cmd.Env = env
|
|
output, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("git %s: %v\n%s", strings.Join(args, " "), err, string(output))
|
|
}
|
|
return string(output)
|
|
}
|
|
|
|
func hookProcessString(value string) *string {
|
|
return &value
|
|
}
|