gastownhall__beads/scripts/pull_dolt_image_test.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":    3,
		"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
}