beads/scripts/pull_dolt_image_test.go
Julian Knutsen 9a91f0629e
ci(bazel): run the differential regression suite under Bazel; retire regression.yml (#7324)
regression.yml ran `go test -tags=regression ./tests/regression/...` on a
GitHub runner: it built the candidate with `go build`, downloaded the v0.49.6
baseline release over the network, and pulled the dolt-sql-server image.
None of that works on rbe-west workers (no network for fork lanes, no docker).

- tools/bazel/bd_releases.bzl: a module extension that reads
  scripts/migration-test/release-catalog.json and declares one repository per
  catalog release with a linux_amd64 asset digest (bd_release_<version>,
  verified against the catalog's sha256), behind the @bd_releases hub
  (@bd_releases//:<version>, plus versions.bzl). Adding a release is a
  catalog change only; nothing downloads until a test declares one.
- //tests/regression:regression_test: the suite's files build under
  `regression || integration`, so gazelle generates the target. It runs the
  injected non-race bd_for_tests (BEADS_TEST_BD_BINARY) against
  @bd_releases//:v0.49.6 (BD_REGRESSION_BASELINE_BIN), both over a hermetic
  dolt sql-server (BEADS_TEST_DOLT_SERVER=local, required), in 8 shards.
  TestMain checks the baseline reports BASELINE_VERSION, so the label and the
  file cannot drift. Tagged dolt-server-cmd: bazel.yml's bazel-cmd-dolt lane,
  which pr.yml's gate requires, runs it remotely; test result caching stands
  in for the old path detector.
- A plain `go test -tags=integration ./...` (nightly) compiles the files but
  skips the suite; only -tags=regression (make test-regression) or Bazel
  runs it.
- regression.yml, main.yml's warm-up compile for it and the policy tests that
  pinned its jobs are removed.

Refs: ga-96smfk.19

Co-authored-by: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-07 01:41:12 +00:00

198 lines
5.3 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{
"pr.yml": 2, // test-domain-uow, contract-corpus
"pr-risk.yml": 3,
}
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 := requireHostTool(t, "bash")
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
}