beads/scripts/pull_dolt_image_test.go
ecuthiell a2cc86ee3a
test(scripts): stabilize Git Bash shim paths (saa-cgh.55) (#5465)
Resolve shim and state paths under the same minimal Bash environment used by
the test commands so Git for Windows cannot remap /tmp between setup and
execution.

Reset the effective command PATH inside profile-free Bash and prove docker,
sleep, and go resolve to the generated shims before either target script runs.
This keeps ambient host tools and real retry sleeps out of the harnesses while
preserving their exact argv, call-count, and exit-status assertions.

Agent-Signature: codex-gpt-5-unknown-reasoning on behalf of Ewen Cuthiell
2026-08-09 01:05:13 -07:00

203 lines
5.4 KiB
Go

package scripts_test
import (
"errors"
"os"
"os/exec"
"path/filepath"
"runtime"
"strconv"
"strings"
"testing"
)
const doltSQLServerImage = "dolthub/dolt-sql-server:2.2.0"
func TestPullDoltImageRetriesTransientFailures(t *testing.T) {
tests := []struct {
name string
failures int
wantExit int
wantPulls int
wantSleeps int
}{
{name: "immediate success", failures: 0, wantExit: 0, wantPulls: 1, wantSleeps: 0},
{name: "eventual success", failures: 2, wantExit: 0, wantPulls: 3, wantSleeps: 2},
{name: "exhausted retries", failures: 3, wantExit: 42, wantPulls: 3, wantSleeps: 2},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
run := runPullDoltImage(t, test.failures)
if got := pullDoltExitCode(run.err); got != test.wantExit {
t.Fatalf("exit = %d, want %d; error=%v\n%s", got, test.wantExit, run.err, run.output)
}
if len(run.dockerCalls) != test.wantPulls {
t.Fatalf("docker pull count = %d, want %d; calls=%q\n%s", len(run.dockerCalls), test.wantPulls, run.dockerCalls, run.output)
}
for _, call := range run.dockerCalls {
if call != "pull "+doltSQLServerImage {
t.Fatalf("docker call = %q, want %q", call, "pull "+doltSQLServerImage)
}
}
if len(run.sleepCalls) != test.wantSleeps {
t.Fatalf("sleep count = %d, want %d; calls=%q\n%s", len(run.sleepCalls), test.wantSleeps, run.sleepCalls, run.output)
}
for _, call := range run.sleepCalls {
if call != "5" {
t.Fatalf("sleep call = %q, want 5", call)
}
}
})
}
}
func TestDoltImagePullWorkflowsUseRetryHelper(t *testing.T) {
wantCalls := map[string]int{
"main.yml": 2,
"pr.yml": 2,
"pr-risk.yml": 2,
"regression.yml": 1,
}
workflowsDir := filepath.Join(sourceRepoRoot(t), ".github", "workflows")
for name, want := range wantCalls {
data, err := os.ReadFile(filepath.Join(workflowsDir, name))
if err != nil {
t.Fatal(err)
}
text := string(data)
if got := strings.Count(text, "run: ./scripts/ci/pull-dolt-image.sh"); got != want {
t.Errorf("%s retry-helper calls = %d, want %d", name, got, want)
}
}
workflowPaths, err := filepath.Glob(filepath.Join(workflowsDir, "*.y*ml"))
if err != nil {
t.Fatal(err)
}
for _, path := range workflowPaths {
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
if strings.Contains(string(data), "docker pull "+doltSQLServerImage) {
t.Errorf("%s still pulls the Dolt image without retries", filepath.Base(path))
}
}
}
func TestPullDoltImageHelperIsExecutable(t *testing.T) {
if runtime.GOOS == "windows" {
t.Skip("Windows does not preserve Unix executable bits")
}
path := filepath.Join(sourceRepoRoot(t), "scripts", "ci", "pull-dolt-image.sh")
info, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
if info.Mode().Perm()&0o111 == 0 {
t.Fatalf("%s is not executable", path)
}
}
type pullDoltRun struct {
output string
dockerCalls []string
sleepCalls []string
err error
}
func runPullDoltImage(t *testing.T, failures int) pullDoltRun {
t.Helper()
bash, err := exec.LookPath("bash")
if err != nil {
t.Skipf("bash is required to test pull-dolt-image.sh: %v", err)
}
bin := t.TempDir()
stateDir := t.TempDir()
dockerLog := filepath.Join(stateDir, "docker-calls")
sleepLog := filepath.Join(stateDir, "sleep-calls")
for _, path := range []string{dockerLog, sleepLog} {
if err := os.WriteFile(path, nil, 0o600); err != nil {
t.Fatal(err)
}
}
writeExecutable(t, filepath.Join(bin, "docker"), `#!/bin/sh
set -eu
count=0
if [ -s "$DOLT_PULL_CALL_COUNT" ]; then
IFS= read -r count <"$DOLT_PULL_CALL_COUNT"
fi
count=$((count + 1))
printf '%s\n' "$count" >"$DOLT_PULL_CALL_COUNT"
printf '%s\n' "$*" >>"$DOLT_PULL_DOCKER_LOG"
if [ "$count" -le "$DOLT_PULL_FAILURES" ]; then
exit 42
fi
`)
writeExecutable(t, filepath.Join(bin, "sleep"), `#!/bin/sh
set -eu
printf '%s\n' "$*" >>"$DOLT_PULL_SLEEP_LOG"
`)
pathEnv := shellPathEnv()
binPath := shellPathUnderEnv(t, bash, bin, pathEnv)
statePath := shellPathUnderEnv(t, bash, stateDir, pathEnv)
commandPath := binPath + ":" + os.Getenv("PATH") + ":/usr/bin:/bin"
if runtime.GOOS == "windows" {
commandPath = binPath + ":/usr/bin:/bin"
}
root := sourceRepoRoot(t)
env := []string{
"PATH=" + os.Getenv("PATH"),
"BEADS_TEST_COMMAND_PATH=" + commandPath,
"LC_ALL=C",
"LANG=C",
"BASH_ENV=",
"ENV=",
"DOLT_PULL_CALL_COUNT=" + statePath + "/docker-call-count",
"DOLT_PULL_DOCKER_LOG=" + statePath + "/docker-calls",
"DOLT_PULL_SLEEP_LOG=" + statePath + "/sleep-calls",
"DOLT_PULL_FAILURES=" + strconv.Itoa(failures),
}
requireShellCommandPath(t, bash, root, env, "docker", binPath+"/docker")
requireShellCommandPath(t, bash, root, env, "sleep", binPath+"/sleep")
cmd := bashScriptCommand(bash, "scripts/ci/pull-dolt-image.sh")
cmd.Dir = root
cmd.Env = env
output, runErr := cmd.CombinedOutput()
dockerCalls := readCallLines(t, dockerLog)
sleepCalls := readCallLines(t, sleepLog)
return pullDoltRun{output: string(output), dockerCalls: dockerCalls, sleepCalls: sleepCalls, err: runErr}
}
func readCallLines(t *testing.T, path string) []string {
t.Helper()
data, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
text := strings.TrimSpace(string(data))
if text == "" {
return nil
}
return strings.Split(text, "\n")
}
func pullDoltExitCode(err error) int {
if err == nil {
return 0
}
var exitErr *exec.ExitError
if errors.As(err, &exitErr) {
return exitErr.ExitCode()
}
return -1
}