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
203 lines
5.4 KiB
Go
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
|
|
}
|