#!/bin/sh
# script/test: run the test suite. Quiet on success; on failure, rerun
# verbosely for full diagnostic output (the exit 1 ensures the rerun
# never turns a failure into a pass).
set -eu

ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"

# The flags live in one function so the quiet run and the verbose rerun
# below cannot drift apart. A rerun that used different flags would
# diagnose a different program than the one that failed.
#
# -count=1 is the documented way to bypass Go's test result cache, and
# it is not optional here. Without it, a package whose inputs are
# unchanged prints `ok <pkg> (cached)`, and that line is
# indistinguishable -- to every check this repo performs -- from a
# package that actually ran. The whole suite reports its full set of
# `ok` lines in under half a second having executed nothing. That
# matters beyond the local inner loop: the Dockerfile's `RUN make test`
# is forced to re-execute by CHECK_EPOCH, but a GOCACHE baked into an
# earlier image layer survives into the re-executed step, so the step
# can re-run and still do no work. It is applied unconditionally rather
# than only in the containerised path because the pre-commit hook runs
# this same script; a gate that is honest only in CI is dishonest
# exactly where people lean on it most.
#
# -timeout is a hang backstop, not a performance budget: its job is to
# turn a deadlocked test into a stack dump instead of a wedged CI job,
# so it wants to sit far above the slowest legitimate runtime, not just
# above it. It is per test binary and covers test execution only -- the
# clock starts inside testing.M.Run, after compilation and linking, so
# build time is not charged against it. (Measured: a containerised run
# with an empty GOCACHE reports per-package durations within noise of a
# warm host run. A shell `timeout 30 go test ./...` would include
# compilation, but that is a different mechanism from this flag.) The
# slowest packages are internal/database and internal/vaultik, measured
# between 6.4s and 8.1s under -race, the high end being a cold
# containerised run on a contended host. Against that 8.1s worst case
# 30s left only 3.7x headroom, thin for a loaded or throttled CI
# runner; 120s leaves about 15x while still bounding a hung package --
# including the verbose rerun below -- to a few minutes.
run_tests() {
    go test -race -timeout 120s -count=1 "$@" ./...
}

main() {
    cd "$ROOT"
    run_tests || {
        echo "--- Rerunning with -v for details ---"
        run_tests -v
        exit 1
    }
}

main "$@"