home-network-k3s-impl/ci/tests/touched-requirements-base.test.sh

#!/usr/bin/env bash
# ci/tests/touched-requirements-base.test.sh — regression tests for BASE-REF RESOLUTION
# in ci/touched-requirements.sh.
#
# THE BUG THESE LOCK DOWN (2026-08-31, local/CI divergence):
#   `make -C ci gate` on a feature branch printed
#       "no changed files vs base; empty touched-requirement set"
#   and then "MERGE GATE: PASS" — while CI, with a correct base, computed 17 touched
#   requirements and BLOCKED on real coverage debt. Root cause: EVERY way of failing to
#   establish a diff base degraded silently to an EMPTY touched set and exit 0. An empty
#   set means conformance/run.sh is invoked without `--requirements`, which means its
#   coverage `--require` gate never runs — so the gate reported PASS having checked
#   nothing. A false green is worse than a red.
#
#   The fix: an undeterminable base is a LOUD exit 3 (ci/README.md's SKIPPED code) with
#   EMPTY stdout and a machine-readable reason code, never exit 0. These tests assert
#   that for each way the base can be undeterminable, and assert the good paths still work.
#
# The tests point the real script at THROWAWAY git repos via the REPO_ROOT override
# (ci/lib.sh honours a pre-set REPO_ROOT); the script runs from its true location so it
# still sources the real lib.sh. No network, no cluster, and the working repo is never
# touched.
#
# Run:  ci/tests/touched-requirements-base.test.sh     (or `make -C ci test`)
set -uo pipefail    # NOT -e: these tests deliberately run a script that exits non-zero.

CI_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
SCRIPT="${CI_DIR}/touched-requirements.sh"

PASS=0 FAIL=0
ok()  { printf '  ok   %s\n' "$*"; PASS=$((PASS+1)); }
bad() { printf '  FAIL %s\n' "$*" >&2; FAIL=$((FAIL+1)); }

TMP="$(mktemp -d)"
trap 'rm -rf "$TMP"' EXIT

# newrepo <dir> — a throwaway repo with one baseline commit on `main`.
newrepo() {
  local d="$1"
  mkdir -p "$d/notes"
  git -C "$d" init -q -b main
  git -C "$d" config user.email [email protected]
  git -C "$d" config user.name t
  git -C "$d" config commit.gpgsign false   # throwaway: never sign (ignore host gpg config)
  echo baseline > "$d/notes/base.txt"
  git -C "$d" add -A && git -C "$d" commit -qm baseline
}

# commit_touching <dir> <text> — a commit whose content declares an R-ID.
commit_touching() {
  local d="$1" text="$2"
  printf 'name: %s\n' "$text" > "$d/notes/decl.yaml"
  git -C "$d" add -A && git -C "$d" commit -qm change
}

# Runs the script in <dir>; sets RC, OUT (stdout), ERRTXT (stderr), REASON.
run_in() {
  local d="$1"; shift
  local reason_file="${TMP}/reason.$$"
  : > "$reason_file"
  OUT="$(REPO_ROOT="$d" TOUCHED_REASON_FILE="$reason_file" "$@" "$SCRIPT" 2>"${TMP}/err.$$")"
  RC=$?
  ERRTXT="$(cat "${TMP}/err.$$")"
  REASON="$(cat "$reason_file")"
}

# assert_refusal <label> <expected-reason>
assert_refusal() {
  local label="$1" want="$2"
  [ "$RC" = 3 ]        && ok "${label}: exits 3 (SKIPPED), not 0" || bad "${label}: rc=${RC}, expected 3"
  [ -z "$OUT" ]        && ok "${label}: stdout is EMPTY (no silent requirement list)" \
                       || bad "${label}: stdout was '${OUT}'"
  [ "$REASON" = "$want" ] && ok "${label}: reason code '${want}'" \
                          || bad "${label}: reason '${REASON}', expected '${want}'"
  grep -q "NOT DETERMINABLE" <<<"$ERRTXT" && ok "${label}: announces the refusal LOUDLY on stderr" \
                                          || bad "${label}: stderr lacked the loud banner"
}

echo "== case 1: a branch ahead of local main (no remote) resolves and reports"
R1="${TMP}/r1"; newrepo "$R1"
git -C "$R1" checkout -q -b feature
commit_touching "$R1" implements-R-ALPHA-01
run_in "$R1"
[ "$RC" = 0 ] && ok "ahead-of-main: exits 0" || bad "ahead-of-main: rc=${RC}"
grep -qx "R-ALPHA-01" <<<"$OUT" && ok "ahead-of-main: emits the touched R-ID" \
                                || bad "ahead-of-main: output was '${OUT}'"
grep -q "diff base: main" <<<"$ERRTXT" && ok "ahead-of-main: names the base it used" \
                                       || bad "ahead-of-main: base not reported: ${ERRTXT}"

echo "== case 2: THE FALSE GREEN — HEAD is the base branch itself"
# This is the state that produced 'no changed files vs base' + 'MERGE GATE: PASS'
# locally while CI blocked. It must now refuse, not report an empty set.
R2="${TMP}/r2"; newrepo "$R2"
git -C "$R2" checkout -q -b feature
commit_touching "$R2" implements-R-ALPHA-01
git -C "$R2" checkout -q main            # <- sitting on the base branch
run_in "$R2"
assert_refusal "on-base" "on-base"

echo "== case 3: a branch already merged into the base (HEAD is an ancestor)"
R3="${TMP}/r3"; newrepo "$R3"
git -C "$R3" checkout -q -b feature
commit_touching "$R3" implements-R-ALPHA-01
git -C "$R3" checkout -q main
git -C "$R3" merge -q --no-edit feature
git -C "$R3" checkout -q feature         # feature is now behind main
run_in "$R3"
assert_refusal "already-merged" "on-base"

echo "== case 4: no base ref resolves at all (no main, no origin/main)"
R4="${TMP}/r4"; newrepo "$R4"
git -C "$R4" checkout -q -b work
commit_touching "$R4" implements-R-ALPHA-01
git -C "$R4" branch -q -D main
run_in "$R4"
assert_refusal "no-base-ref" "no-base"

echo "== case 5: a single-commit repo with no main (the removed HEAD~1 last resort)"
# HEAD~1 does not exist here. The old code fell back to it, the diff failed, and the
# empty result was reported as 'no changed files' + exit 0 — a silent false green.
R5="${TMP}/r5"; mkdir -p "$R5/notes"
git -C "$R5" init -q -b work
git -C "$R5" config user.email [email protected]; git -C "$R5" config user.name t
git -C "$R5" config commit.gpgsign false
echo only > "$R5/notes/only.txt"; git -C "$R5" add -A; git -C "$R5" commit -qm only
run_in "$R5"
assert_refusal "single-commit-no-main" "no-base"

echo "== case 6: BASE_REF names a ref that does not exist"
R6="${TMP}/r6"; newrepo "$R6"
git -C "$R6" checkout -q -b feature
commit_touching "$R6" implements-R-ALPHA-01
run_in "$R6" env BASE_REF=refs/heads/nope
assert_refusal "bogus-BASE_REF" "no-base"

echo "== case 7: GITHUB_BASE_REF set but absent from the checkout (shallow clone)"
R7="${TMP}/r7"; newrepo "$R7"
git -C "$R7" checkout -q -b feature
commit_touching "$R7" implements-R-ALPHA-01
run_in "$R7" env GITHUB_BASE_REF=release-9
assert_refusal "missing-GITHUB_BASE_REF" "no-base"

echo "== case 8: origin/main is preferred over a stale local main, and staleness warns"
R8="${TMP}/r8"; newrepo "$R8"
UP="${TMP}/r8-origin.git"; git init -q --bare -b main "$UP"
git -C "$R8" remote add origin "$UP"
git -C "$R8" push -q origin main
# advance origin/main beyond the local main ref, then branch off it
git -C "$R8" checkout -q -b ahead
echo more > "$R8/notes/more.txt"; git -C "$R8" add -A; git -C "$R8" commit -qm more
git -C "$R8" push -q origin ahead:main
git -C "$R8" fetch -q origin
git -C "$R8" checkout -q -b feature origin/main
commit_touching "$R8" implements-R-ALPHA-01
run_in "$R8"
[ "$RC" = 0 ] && ok "origin-preferred: exits 0" || bad "origin-preferred: rc=${RC}"
grep -q "diff base: origin/main" <<<"$ERRTXT" && ok "origin-preferred: uses origin/main, not local main" \
                                              || bad "origin-preferred: base line was: ${ERRTXT}"
grep -q "may be stale" <<<"$ERRTXT" && ok "origin-preferred: warns that local main differs" \
                                    || bad "origin-preferred: no staleness warning"
grep -qx "R-ALPHA-01" <<<"$OUT" && ok "origin-preferred: emits the touched R-ID" \
                                || bad "origin-preferred: output was '${OUT}'"

echo
if [ "$FAIL" -eq 0 ]; then
  echo "touched-requirements base-resolution tests: PASS (${PASS} assertions)"; exit 0
fi
echo "touched-requirements base-resolution tests: FAIL (${FAIL} failed, ${PASS} passed)" >&2
exit 1