forgedock 1.28.0 → 1.29.0

package/scripts/test-map.sh

@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+# SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+# SPDX-License-Identifier: AGPL-3.0-or-later
+#
+# test-map.sh — deterministic `file glob → check command` map for a repo (forge#4272). No LLM, no network, runs none of
+# the repo's commands: git + jq + awk only (no yq). Codebase-agnostic: node, python, go, make and CI workflow steps.
+#
+# Usage: test-map.sh [--repo-path DIR] [--output FILE | --stdout]
+#   default output <repo>/.forge/test-map.json, rewritten on every run (a regenerable cache; deleting it restores the
+#   pre-PR step's `learned.test_commands` behaviour).
+# Output: {"version":1,"entries":[{"globs":[...],"command","cwd","source"}]}, sorted by source then command; entries
+#   with the same (command, cwd) are merged (globs unioned, first source kept).
+# Sources:
+#   package.json (root + every tracked one outside node_modules): scripts test/lint/typecheck/type-check/check →
+#     `<pm> run <script>` in the package dir (pm from the root lockfile), JS/TS globs under that dir
+#   pytest (pyproject [tool.pytest*], pytest.ini, setup.cfg [tool:pytest], conftest.py) and ruff config → `pytest`,
+#     `ruff check .` (through `uv run` / `poetry run` when that lockfile exists), `**/*.py`
+#   go.mod (dir D) → `go test ./...`, `go vet ./...` in D, `D/**/*.go`, `D/go.mod`, `D/go.sum`
+#   Makefile / GNUmakefile targets test/lint/check/typecheck/vet → `make <target>`, `**`
+#   .github/workflows/*.yml|*.yaml `run:` steps (one command per line of a `|` block, a `>` block is one command;
+#     install/setup lines skipped): globs
+#     from the tool (python/go/shell/js), else the workflow's `paths:` filter, else `**`. A step whose job id, job
+#     name, step name or command matches deploy/publish/release/push/secret is never mapped (forge#4297): the engine
+#     runs these commands before a PR, so only check steps belong here.
+# Exit: 0 ok | 2 usage or bad repo path. bash 3.2 portable.
+set -uo pipefail
+
+die() { echo "test-map: $*" >&2; exit 2; }
+command -v jq >/dev/null 2>&1 || die "jq is required"
+REPO="."; OUT=""; STDOUT=0
+while [ $# -gt 0 ]; do
+  case "$1" in
+    --repo-path) [ $# -ge 2 ] && [ -n "$2" ] || die "usage: test-map.sh [--repo-path DIR] [--output FILE | --stdout]"; REPO="$2"; shift 2 ;;
+    --output) [ $# -ge 2 ] && [ -n "$2" ] || die "usage: test-map.sh [--repo-path DIR] [--output FILE | --stdout]"; OUT="$2"; shift 2 ;;
+    --stdout) STDOUT=1; shift ;;
+    *) die "unknown option: $1" ;;
+  esac
+done
+[ -d "$REPO" ] || die "repo path not found: $REPO"
+case "$OUT" in ""|/*) ;; *) OUT="$PWD/$OUT" ;; esac
+cd "$REPO" || die "cannot enter $REPO"
+
+T=$(mktemp -d "${TMPDIR:-/tmp}/test-map.XXXXXX") || die "mktemp failed"
+trap 'rm -rf "$T"' EXIT
+if git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+  # -z and quotepath=off (#4298): non-ASCII and spaced paths come out verbatim, never C-quoted
+  git -c core.quotepath=off ls-files -z --cached --others --exclude-standard | tr '\0' '\n' > "$T/files"
+else
+  find . -type f -not -path './.git/*' | sed 's|^\./||' | sort > "$T/files"
+fi
+: > "$T/rows"
+# row: source TAB cwd TAB command TAB globs separated by US (\037, #4298: a glob may contain spaces)
+US="$(printf '\037')"
+row() { printf '%s\t%s\t%s\t%s\n' "$1" "$2" "$3" "$4" >> "$T/rows"; }
+JS_EXT="js jsx ts tsx mjs cjs"
+# globs for the extensions in $2 under dir $1 ("." = repo root)
+ext_globs() {
+  g=""; pre=""; [ "$1" = "." ] || pre="$1/"
+  for e in $2; do g="$g$US${pre}**/*.$e"; done
+  printf '%s' "${g#"$US"}"
+}
+
+# ---- package.json scripts ----
+PM=npm
+[ -f yarn.lock ] && PM=yarn
+[ -f pnpm-lock.yaml ] && PM=pnpm
+grep -E '(^|/)package\.json$' "$T/files" | grep -v -E '(^|/)node_modules/' | sort | while IFS= read -r pj; do
+  [ -f "$pj" ] || continue
+  d=$(dirname "$pj")
+  globs="$(ext_globs "$d" "$JS_EXT")$US$pj"
+  tag=""
+  if [ -n "$(ls "$d"/vitest.config.* "$d"/jest.config.* 2>/dev/null)" ] || jq -e 'has("jest")' "$pj" >/dev/null 2>&1; then tag=" (vitest/jest config)"; fi
+  jq -r '(.scripts // {}) | to_entries[] | select(.value | type == "string") | .key' "$pj" 2>/dev/null | while IFS= read -r s; do
+    case "$s" in
+      test) row "$pj#scripts.$s$tag" "$d" "$PM run $s" "$globs" ;;
+      lint|typecheck|type-check|check) row "$pj#scripts.$s" "$d" "$PM run $s" "$globs" ;;
+    esac
+  done
+done
+
+# ---- python ----
+RUN=""
+[ -f poetry.lock ] && RUN="poetry run "
+[ -f uv.lock ] && RUN="uv run "
+PY_SRC=""
+if [ -f pyproject.toml ] && grep -qE '^\[tool\.pytest' pyproject.toml; then PY_SRC="pyproject.toml#tool.pytest"
+elif [ -f pytest.ini ]; then PY_SRC="pytest.ini"
+elif [ -f setup.cfg ] && grep -qE '^\[tool:pytest\]' setup.cfg; then PY_SRC="setup.cfg#tool:pytest"
+elif grep -qE '(^|/)conftest\.py$' "$T/files"; then PY_SRC="conftest.py"; fi
+[ -n "$PY_SRC" ] && row "$PY_SRC" "." "${RUN}pytest" "**/*.py$US**/conftest.py"
+RUFF_SRC=""
+if [ -f pyproject.toml ] && grep -qE '^\[tool\.ruff' pyproject.toml; then RUFF_SRC="pyproject.toml#tool.ruff"
+elif [ -f ruff.toml ]; then RUFF_SRC="ruff.toml"
+elif [ -f .ruff.toml ]; then RUFF_SRC=".ruff.toml"; fi
+[ -n "$RUFF_SRC" ] && row "$RUFF_SRC" "." "${RUN}ruff check ." "**/*.py"
+
+# ---- go ----
+grep -E '(^|/)go\.mod$' "$T/files" | grep -v -E '(^|/)vendor/' | sort | while IFS= read -r gm; do
+  d=$(dirname "$gm"); pre=""; [ "$d" = "." ] || pre="$d/"
+  globs="${pre}**/*.go$US${pre}go.mod$US${pre}go.sum"
+  row "$gm" "$d" "go test ./..." "$globs"
+  row "$gm" "$d" "go vet ./..." "$globs"
+done
+
+# ---- Makefile ----
+for mf in Makefile GNUmakefile; do
+  [ -f "$mf" ] || continue
+  grep -oE '^(test|lint|check|typecheck|vet)[[:space:]]*:' "$mf" | sed -E 's/[[:space:]]*:$//' | sort -u | while IFS= read -r t; do
+    row "$mf#$t" "." "make $t" "**"
+  done
+done
+
+# ---- CI workflow run: steps ----
+# Emits: job US jobname US stepname US command (US = \037, so empty names survive `read`), one per command line; and P TAB path for each `paths:` filter item
+# before `jobs:`. A block ends at the first non-blank line not indented past the `run` key (sibling keys such as env:).
+wf_extract() {
+  awk '
+    function indent(s) { match(s, /^ */); return RLENGTH }
+    function unq(s) { sub(/^[ \t]+/, "", s); sub(/[ \t]+$/, "", s); if (s ~ /^".*"$/ || s ~ /^\x27.*\x27$/) s = substr(s, 2, length(s) - 2); return s }
+    function emit(c) { c = unq(c); if (c != "") print job "\037" jname "\037" sname "\037" c }
+    BEGIN { injobs = 0; jind = -1; block = 0; inpaths = 0; job = ""; jname = ""; sname = "" }
+    {
+      line = $0; sub(/\r$/, "", line)
+      if (block) {
+        if (line ~ /^[ \t]*$/) next
+        if (indent(line) > bind) {
+          l = line; sub(/^ +/, "", l)
+          if (fold) { pend = (pend == "" ? l : pend " " l); next }
+          if (pend != "") { l = pend " " l; pend = "" }
+          if (l ~ /\\$/) { pend = substr(l, 1, length(l) - 1); sub(/[ \t]+$/, "", pend); next }
+          emit(l); next
+        }
+        if (pend != "") { emit(pend); pend = "" }
+        block = 0
+      }
+      if (line ~ /^jobs:[ \t]*$/) { injobs = 1; inpaths = 0; next }
+      if (!injobs) {
+        if (line ~ /^[ \t]*paths:[ \t]*$/) { inpaths = 1; pind = indent(line); next }
+        if (inpaths) {
+          if (line ~ /^[ \t]*-[ \t]/ && indent(line) >= pind) { p = line; sub(/^[ \t]*-[ \t]*/, "", p); sub(/[ \t]+#.*$/, "", p); print "P\t" unq(p); next }
+          if (line !~ /^[ \t]*$/ && line !~ /^[ \t]*#/) inpaths = 0
+        }
+        next
+      }
+      if (line ~ /^[^ \t#]/) { injobs = 0; next }
+      if (line ~ /^ +[A-Za-z0-9_-]+:[ \t]*$/ && (jind < 0 || indent(line) == jind)) { jind = indent(line); job = line; sub(/^ +/, "", job); sub(/:.*$/, "", job); jname = ""; sname = ""; next }
+      if (line ~ /^[ \t]*-[ \t]/) sname = ""
+      if (line ~ /^[ \t]*(-[ \t]+)?name:/) {
+        nm = line; sub(/^[ \t]*(-[ \t]+)?name:[ \t]*/, "", nm); sub(/[ \t]+#.*$/, "", nm)
+        if (line !~ /^[ \t]*-[ \t]/ && indent(line) == jind + 2) jname = unq(nm); else sname = unq(nm)
+        next
+      }
+      if (line ~ /^[ \t]*(-[ \t]+)?run:/) {
+        rest = line; sub(/^[ \t]*(-[ \t]+)?run:[ \t]*/, "", rest); sub(/[ \t]+#.*$/, "", rest)
+        # bind = the column of the `run` key: step keys after it (env:, shell:) sit there and end the block
+        if (rest ~ /^[|>][-+0-9]*$/) { block = 1; pend = ""; fold = (rest ~ /^>/); bind = match(line, /run:/) - 1; next }
+        emit(rest)
+      }
+    }
+    END { if (block && pend != "") emit(pend) }
+  ' "$1"
+}
+skip_cmd() {
+  case "$1" in
+    \#*|echo\ *|echo|cd\ *|export\ *|set\ *|if\ *|then|fi|else|for\ *|do|done|\}*|\{*|*'$GITHUB_'*|*'>> $GITHUB'*) return 0 ;;
+    npm\ ci*|npm\ install*|npm\ i|npm\ i\ *|pnpm\ install*|pnpm\ i|yarn|yarn\ install*|pip\ install*|pip3\ install*|python*\ -m\ pip\ install*|uv\ sync*|uv\ pip\ install*|poetry\ install*|go\ mod\ download*|apt-get*|sudo\ *|corepack\ *|brew\ *) return 0 ;;
+  esac
+  return 1
+}
+# forge#4297: deploy, publish, release, push and secret-using steps are never check commands
+deploy_step() {
+  grep -qiE 'deploy|publish|release|push|secret' <<<"$*"
+}
+tool_globs() {
+  c=" $1 "
+  case "$c" in
+    *[\ /]ruff\ *|*[\ /]flake8\ *|*[\ /]pylint\ *|*[\ /]mypy\ *|*[\ /]black\ *|*[\ /]pytest\ *) printf '**/*.py'; return ;;
+    *[\ /]golangci-lint\ *|*[\ /]gofmt\ *|*[\ /]staticcheck\ *|*\ go\ *) printf '**/*.go'; return ;;
+    *[\ /]shellcheck\ *|*\ bash\ *.sh\ *|*\ sh\ *.sh\ *) printf '**/*.sh'; return ;;
+    *[\ /]eslint\ *|*[\ /]tsc\ *|*[\ /]prettier\ *|*[\ /]vitest\ *|*[\ /]jest\ *|*\ node\ --test*|*\ npm\ *|*\ pnpm\ *|*\ yarn\ *|*\ npx\ *) ext_globs . "$JS_EXT"; return ;;
+  esac
+  printf ''
+}
+grep -E '^\.github/workflows/[^/]+\.(yml|yaml)$' "$T/files" | sort | while IFS= read -r wf; do
+  [ -f "$wf" ] || continue
+  wf_extract "$wf" > "$T/wf"
+  paths=$(awk -F'\t' '$1 == "P" { printf "%s\037", $2 }' "$T/wf"); paths=${paths%"$US"}
+  awk -F'\t' '$1 != "P"' "$T/wf" | while IFS="$(printf '\037')" read -r job jname sname cmd; do
+    skip_cmd "$cmd" && continue
+    deploy_step "$job" "$jname" "$sname" "$cmd" && continue
+    g=$(tool_globs "$cmd")
+    [ -n "$g" ] || g="$paths"
+    [ -n "$g" ] || g="**"
+    row "$wf#jobs.$job" "." "$cmd" "$g"
+  done
+done
+
+MAP=$(jq -R -s -c '
+  [split("\n")[] | select(length > 0) | split("\t") | {source: .[0], cwd: .[1], command: .[2], globs: (.[3] | split("\u001f") | map(select(length > 0)))}]
+  | sort_by(.source, .command)
+  | reduce .[] as $e ({order: [], by: {}};
+      ([$e.command, $e.cwd] | tojson) as $k
+      | if .by[$k] then .by[$k].globs += ($e.globs - .by[$k].globs)
+        else .order += [$k] | .by[$k] = {globs: $e.globs, command: $e.command, cwd: $e.cwd, source: $e.source} end)
+  | {version: 1, entries: [.by[.order[]]]}' < "$T/rows") || die "jq failed"
+
+if [ "$STDOUT" = 1 ]; then printf '%s\n' "$MAP"; exit 0; fi
+[ -n "$OUT" ] || OUT=".forge/test-map.json"
+mkdir -p "$(dirname "$OUT")" || die "cannot create $(dirname "$OUT")"
+printf '%s\n' "$MAP" > "$OUT.tmp.$$" && mv "$OUT.tmp.$$" "$OUT" || die "cannot write $OUT"
+echo "$OUT"

package/scripts/test-map.test.sh

@@ -0,0 +1,165 @@
+#!/usr/bin/env bash
+# test-map.test.sh — cases for scripts/test-map.sh over the node, python and go fixtures (forge#4272).
+# SPDX-FileCopyrightText: Copyright (c) RapierCraft Studios
+# SPDX-License-Identifier: AGPL-3.0-or-later
+set -uo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+S="$HERE/test-map.sh"
+SEL="$HERE/../bin/lean/testmap.mjs"
+FIX="$HERE/fixtures/test-map"
+PASS=0; FAILN=0
+TMP="$(mktemp -d "${TMPDIR:-/tmp}/test-map-test.XXXXXX")"; trap 'rm -rf "$TMP"' EXIT
+ok() { PASS=$((PASS+1)); }
+bad() { FAILN=$((FAILN+1)); echo "FAIL: $1"; }
+eq() { if [ "$2" = "$3" ]; then ok; else bad "$1 (got: $2 want: $3)"; fi }
+
+# copy a fixture into a fresh git repo and build its map
+setup() {
+  rm -rf "$TMP/$1"; cp -R "$FIX/$1" "$TMP/$1"; cd "$TMP/$1" || exit 1
+  git init -q -b main; git config user.email t@example.com; git config user.name t; git config commit.gpgsign false
+  git add -A; git commit -qm init
+  OUTP="$(bash "$S")"; RC=$?
+}
+# selected commands for changed files, sorted, joined by |
+sel() { node "$SEL" --map .forge/test-map.json --select "$@" | LC_ALL=C sort | paste -sd'|' -; }
+
+# ---- 1. node: root scripts for root files, workspace scripts for package files ----
+setup node
+eq "node rc" "$RC" 0
+eq "node output path" "$OUTP" ".forge/test-map.json"
+eq "schema" "$(jq -c '[.version, (.entries | length > 0), (.entries | all(has("globs") and has("command") and has("cwd") and has("source")))]' .forge/test-map.json)" '[1,true,true]'
+eq "non-check script ignored" "$(jq '[.entries[] | select(.command | test("build"))] | length' .forge/test-map.json)" 0
+eq "root file" "$(sel src/a.ts)" "pnpm run lint|pnpm run test"
+eq "package file" "$(sel packages/ui/src/button.tsx)" "cd packages/ui && pnpm run test|cd packages/ui && pnpm run typecheck|pnpm run lint|pnpm run test"
+eq "vitest config noted" "$(jq -r '.entries[] | select(.cwd == "." and .command == "pnpm run test") | .source' .forge/test-map.json)" "package.json#scripts.test (vitest/jest config)"
+eq "unrelated file" "$(sel README.md)" ""
+
+# ---- 2. python: pytest + ruff through uv ----
+setup python
+eq "python rc" "$RC" 0
+eq "python file" "$(sel pkg/mod.py)" "uv run pytest|uv run ruff check ."
+eq "python test file" "$(sel tests/test_mod.py)" "uv run pytest|uv run ruff check ."
+eq "python non-py" "$(sel uv.lock)" ""
+
+# ---- 3. go: go.mod, Makefile and CI workflow steps; CI-only lint step; install lines skipped ----
+setup go
+eq "go rc" "$RC" 0
+eq "go file" "$(sel main.go)" "./scripts/check-docs|go test ./...|go vet ./...|golangci-lint run ./...|make test"
+eq "nested go file" "$(sel internal/util/util.go)" "./scripts/check-docs|go test ./...|go vet ./...|golangci-lint run ./...|make test"
+eq "ci-only lint source" "$(jq -r '.entries[] | select(.command == "golangci-lint run ./...") | .source' .forge/test-map.json)" ".github/workflows/ci.yml#jobs.lint"
+eq "install line skipped" "$(jq '[.entries[] | select(.command | test("mod download"))] | length' .forge/test-map.json)" 0
+eq "paths filter fallback" "$(jq -c '.entries[] | select(.command == "./scripts/check-docs") | .globs' .forge/test-map.json)" '["**.go","go.mod"]'
+eq "docs file" "$(sel README.md)" "make test"
+eq "go.sum" "$(sel go.sum)" "go test ./...|go vet ./...|make test"
+
+# ---- 4. regenerable: a rerun is byte-identical; --stdout writes nothing; --output ----
+cp .forge/test-map.json "$TMP/first.json"
+bash "$S" >/dev/null
+if cmp -s .forge/test-map.json "$TMP/first.json"; then ok; else bad "rerun not byte-identical"; fi
+rm -rf .forge; OUTS="$(bash "$S" --stdout)"
+eq "stdout same map" "$OUTS" "$(cat "$TMP/first.json")"
+eq "stdout writes nothing" "$([ -e .forge ] && echo yes || echo no)" no
+bash "$S" --repo-path "$TMP/go" --output "$TMP/out/map.json" >/dev/null
+if cmp -s "$TMP/out/map.json" "$TMP/first.json"; then ok; else bad "--output differs"; fi
+
+# ---- 5. block runs, continuation lines, setup lines, workflow without paths ----
+mkdir -p "$TMP/wf/.github/workflows"; cd "$TMP/wf" || exit 1
+git init -q -b main
+cat > .github/workflows/lint.yaml <<'EOF'
+on: push
+jobs:
+  checks:
+    runs-on: ubuntu-latest
+    steps:
+      - run: npm ci
+      - run: "shellcheck scripts/*.sh"
+      - run: >-
+          ruff check
+          --fix
+      - run: |
+          echo hi
+          bash scripts/verify.sh \
+            --strict
+          ./custom-check
+EOF
+git add -A
+OUTS="$(bash "$S" --stdout)"
+eq "wf commands" "$(printf '%s' "$OUTS" | jq -r '[.entries[].command] | sort | join("|")')" "./custom-check|bash scripts/verify.sh --strict|ruff check --fix|shellcheck scripts/*.sh"
+eq "wf globs" "$(printf '%s' "$OUTS" | jq -c '[.entries[] | {(.command): .globs}] | add')" '{"./custom-check":["**"],"bash scripts/verify.sh --strict":["**/*.sh"],"ruff check --fix":["**/*.py"],"shellcheck scripts/*.sh":["**/*.sh"]}'
+
+# ---- 5b. forge#4297: `- run: |` then env:/shell: ends the block; deploy/publish/release/push/secret steps dropped ----
+mkdir -p "$TMP/wf2/.github/workflows"; cd "$TMP/wf2" || exit 1
+git init -q -b main
+cat > .github/workflows/ci.yml <<'EOF'
+on:
+  push:
+    branches: [main]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - run: |
+          npm test
+        env:
+          CI: true
+        shell: bash
+      - name: Lint
+        run: |
+          npm run lint
+        working-directory: .
+      - name: Publish to npm
+        run: npm run ship
+      - run: ./scripts/release.sh
+      - run: git push origin HEAD
+      - run: curl -H "token ${{ secrets.TOKEN }}" https://x
+      - run: >-
+          tsc
+          --noEmit
+        shell: bash
+  deploy:
+    name: Ship it
+    runs-on: ubuntu-latest
+    steps:
+      - run: ./ship.sh
+  site:
+    name: Deploy site
+    runs-on: ubuntu-latest
+    steps:
+      - run: ./build-site.sh
+EOF
+git add -A
+OUTS="$(bash "$S" --stdout)"
+eq "wf2 commands" "$(printf '%s' "$OUTS" | jq -r '[.entries[].command] | sort | join("|")')" "npm run lint|npm test|tsc --noEmit"
+
+# ---- 5c. forge#4298: a package dir with a space and a non-ASCII name keeps whole globs; workflow paths with spaces ----
+mkdir -p "$TMP/sp/web app" "$TMP/sp/pkg/ü/src" "$TMP/sp/.github/workflows"; cd "$TMP/sp" || exit 1
+git init -q -b main
+echo '{"name":"root","private":true}' > package.json
+echo '{"name":"web","scripts":{"test":"vitest run"}}' > "web app/package.json"
+echo '{"name":"u","scripts":{"lint":"eslint ."}}' > "pkg/ü/package.json"
+echo 'x' > "pkg/ü/src/a.ts"
+cat > .github/workflows/ci.yml <<'EOF'
+on:
+  push:
+    paths:
+      - "docs site/**"
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    steps:
+      - run: ./build-docs.sh
+EOF
+git add -A
+OUTS="$(bash "$S" --stdout)"
+eq "spaced package globs" "$(printf '%s' "$OUTS" | jq -c '[.entries[] | select(.cwd == "web app") | .globs[]] | map(select(endswith("package.json") or endswith(".js")))')" '["web app/**/*.js","web app/package.json"]'
+eq "non-ASCII package dir" "$(printf '%s' "$OUTS" | jq -r '[.entries[] | select(.command == "npm run lint") | .cwd] | join("|")')" "pkg/ü"
+eq "spaced workflow path filter" "$(printf '%s' "$OUTS" | jq -c '[.entries[] | select(.command == "./build-docs.sh") | .globs]')" '[["docs site/**"]]'
+printf '%s' "$OUTS" > "$TMP/sp-map.json"
+eq "spaced changed file selects its package test" "$(node "$SEL" --map "$TMP/sp-map.json" --select "web app/src/x.js")" "cd 'web app' && npm run test"
+
+# ---- 6. usage ----
+bash "$S" --repo-path "$TMP/missing" >/dev/null 2>&1; eq "bad repo path" "$?" 2
+bash "$S" --nope >/dev/null 2>&1; eq "unknown option" "$?" 2
+
+echo "test-map.test.sh: $PASS passed, $FAILN failed"
+[ "$FAILN" -eq 0 ]

package/scripts/wait-ci-green.sh

@@ -4,7 +4,11 @@
 #
 # wait-ci-green.sh — CI gate every autonomous merge must pass first.
 #
-# Usage: wait-ci-green.sh <pr-number> -R <owner/repo> [--timeout SECONDS] [--interval SECONDS]
+# Usage: wait-ci-green.sh <pr-number> -R <owner/repo> [--timeout SECONDS] [--interval SECONDS] [--ignore-check NAME]...
+#
+# --ignore-check NAME (repeatable): drop checks with exactly that name before deciding. `forgedock/verify` (forge#4270,
+# the lean engine's report-only gate summary) is always ignored, so every caller of this gate treats it the same
+# (forge#4298); requiring it is the repository's branch-protection choice.
 #
 # Waits until every check on the PR has finished, then decides. Fails closed: a merge may
 # proceed ONLY on exit 0. Field test: pipeline agents merged PRs to staging while checks were
@@ -40,17 +44,18 @@ set -uo pipefail
 _TEL="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/lib/telemetry.sh"; [ -f "$_TEL" ] && . "$_TEL" 2>/dev/null
 type forge_emit >/dev/null 2>&1 || forge_emit() { :; }
 
-PR=""; REPO=""
+PR=""; REPO=""; IGNORE='["forgedock/verify"]'
 TIMEOUT="${FORGE_CI_TIMEOUT:-540}"; INTERVAL="${FORGE_CI_INTERVAL:-20}"; SETTLE="${FORGE_CI_SETTLE:-45}"
 GRACE="${FORGE_CI_NO_CHECKS_GRACE:-120}"; REQUIRE="${FORGE_CI_REQUIRE_CHECKS:-0}"
-usage() { echo "CI_GATE: ERROR"; echo "CI_GATE_HEAD: unknown"; echo "usage: wait-ci-green.sh <pr> -R <owner/repo> [--timeout S] [--interval S]" >&2; exit 2; }
+usage() { echo "CI_GATE: ERROR"; echo "CI_GATE_HEAD: unknown"; echo "usage: wait-ci-green.sh <pr> -R <owner/repo> [--timeout S] [--interval S] [--ignore-check NAME]..." >&2; exit 2; }
 while [ $# -gt 0 ]; do
   case "$1" in
     -R) [ $# -ge 2 ] || usage; REPO="$2"; shift 2 ;;
     -R*) REPO="${1#-R}"; REPO="${REPO# }"; shift ;;
     --timeout) [ $# -ge 2 ] || usage; TIMEOUT="$2"; shift 2 ;;
     --interval) [ $# -ge 2 ] || usage; INTERVAL="$2"; shift 2 ;;
-    -h|--help) sed -n '5,32p' "$0"; exit 0 ;;
+    --ignore-check) [ $# -ge 2 ] || usage; IGNORE="$(jq -c --arg n "$2" '. + [$n]' <<<"$IGNORE")"; shift 2 ;;
+    -h|--help) sed -n '5,37p' "$0"; exit 0 ;;
     *) [ -z "$PR" ] || usage; PR="$1"; shift ;;
   esac
 done
@@ -132,6 +137,7 @@ while :; do
     fi
   fi
   errors=0; limited=0; transient=0
+  [ "$IGNORE" = '[]' ] || JSON="$(printf '%s' "$JSON" | jq -c --argjson ig "$IGNORE" '[.[] | select(.name as $n | $ig | index($n) | not)]')"
   cur="$(head_sha)"
   if [ -n "$cur" ] && [ "$cur" != "$START_SHA" ]; then emit ERROR; echo "PR head moved during the wait ($START_SHA -> $cur); re-review the new head"; exit 2; fi
   total=$(printf '%s' "$JSON" | jq 'length')

package/scripts/wait-ci-green.test.sh

@@ -55,6 +55,15 @@ expect "pending then pass" "0|CI_GATE: PASS" "$(run "$(mk pend '[{"name":"a","bu
 expect "pending then fail" "1|CI_GATE: FAIL" "$(run "$(mk pendfail '[{"name":"a","bucket":"pending"}]' '[{"name":"a","bucket":"fail"}]')")"
 expect "pending past timeout" "3|CI_GATE: TIMEOUT" "$(run "$(mk slow '[{"name":"a","bucket":"pending"}]')" --timeout 2)"
 expect "fail wins over pending" "1|CI_GATE: FAIL" "$(run "$(mk mixed '[{"name":"a","bucket":"pending"},{"name":"b","bucket":"fail"}]')")"
+# forge#4270: --ignore-check drops the named check (the lane's own report-only forgedock/verify) before deciding.
+OWN='[{"name":"a","bucket":"pass"},{"name":"forgedock/verify","bucket":"fail"}]'
+# forge#4298: forgedock/verify is ignored by default, so every caller (legacy engine, review-finalize, spec gates) agrees.
+expect "own verify check failing is ignored by default" "0|CI_GATE: PASS" "$(run "$(mk ownfail "$OWN")")"
+expect "default ignore keeps other failures" "1|CI_GATE: FAIL" "$(run "$(mk owndef '[{"name":"b","bucket":"fail"},{"name":"forgedock/verify","bucket":"fail"}]')")"
+expect "usage text lists --ignore-check" "1" "$(bash "$GATE" 2>&1 >/dev/null | grep -c -- '--ignore-check NAME')"
+expect "--ignore-check drops the named failing check" "0|CI_GATE: PASS" "$(run "$(mk ownign "$OWN")" --ignore-check forgedock/verify)"
+expect "--ignore-check keeps other failures" "1|CI_GATE: FAIL" "$(run "$(mk ownother '[{"name":"b","bucket":"fail"},{"name":"forgedock/verify","bucket":"pass"}]')" --ignore-check forgedock/verify)"
+expect "--ignore-check without a name is a usage error" "2|CI_GATE: ERROR" "$(run "$(mk ownusage "$P")" --ignore-check)"
 expect "transient outage then pass" "0|CI_GATE: PASS" "$(run "$(mk blip ERR "$P")")"
 expect "persistent unclassified failure is an ERROR" "2|CI_GATE: ERROR" "$(run "$(mk down ERRX)" --timeout 60)"
 # Rate-limit / 5xx classification: retried, never an ERROR; a window that only saw them ends RATE_LIMITED (rc 4).