agentsclimarketplace

Test gate

Skill gabrieldabbah/genesis/skills/test-gate

Run the full verification battery and block on red before any commit/PR. Use before committing, before claiming a task done, or when the user says "run the tests", "is it green?", "verify before commit", or mentions "/test-gate". Discovers the commands from CLAUDE.md and docs/TESTING.md, brings up hermetic Docker infra if a compose file exists, runs lint → typecheck → unit → property → contract → integration (→ e2e) fail-fast, reads the real output, and refuses to proceed on any failure. Reports what it ran and what it printed; never prints secrets from env or logs.From its SKILL.md

Install
npx -y skills add gabrieldabbah/genesis --skill test-gate

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

One thing to look at

  • 4 stars4 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its file declares

Copied from the file, not written here

The file declares its own license as MIT. That is the author’s claim about this one file, and it is not the same thing as the license GitHub reports for the repository, which is listed with the other numbers below.

SKILL.md

5.5 KB, as published. Nobody here has run it

Test Gate — verify before commit, block on red

Overview

Run the project's full Tier-B battery, read the real output, and stop the moment anything is red — never commit a red tree, never claim "passing" you did not watch pass. The strategy this enforces is the project's docs/TESTING.md. Invocation is the authorization — run end-to-end without a confirm prompt.

This is the project's concrete runner, built from its own commands and infra. Closing ritual: test-gate green, then commit, then /generate-pr.

Arguments & modes

  • $1 = full (default) — the Tier-B PR-gated battery (what blocks a commit/merge).
  • $1 = fast — Tier-A local loop (unit + property + lint), skips Docker/integration for a tight feedback cycle. fast green is not sufficient to commit — run full before committing.

Step 0 — Discover the commands (deterministic — never guess them)

Read the source of truth; do not invent commands:

sed -n '/## Commands/,/^## /p' CLAUDE.md         # the canonical command list
cat docs/TESTING.md                              # tiers, kinds, the Docker infra block, the gate order
ls docker-compose*.y*ml 2>/dev/null              # is there hermetic infra to bring up?

Map what you find to the gate stages and set a shell var per stage from the real discovered command — $LINT, $TYPECHECK, $TEST (the Tier-B suite), $E2E, and $MIGRATE / $SEED for infra. If a stage has no command in this project, leave its var empty, skip it, and say so in the report (an honest "no e2e configured" — never a silent pass). Never read or print .env or secrets: to check a needed var, test presence only ([ -n "$VAR" ] && echo set).

Step 1 — Bring up hermetic infra (only if a compose file exists)

COMPOSE=$(ls docker-compose.test.y*ml docker-compose.y*ml 2>/dev/null | head -1)
if [ -n "$COMPOSE" ]; then
  docker compose -f "$COMPOSE" up -d --wait        # wait for healthchecks; don't race startup
  trap 'docker compose -f "$COMPOSE" down -v' EXIT # ALWAYS tear down + drop volumes, even on failure
  [ -n "$MIGRATE" ] && eval "$MIGRATE"; [ -n "$SEED" ] && eval "$SEED"   # deterministic schema + fixtures
fi

Infra is ephemeral, seeded, isolated — never point integration tests at a shared or staging database. If Docker is unavailable, run unit+property, and report integration as not-run (do not pretend it passed).

Step 2 — Run the battery, fail-fast, reading every output

Order (a red stage stops the rest — fix the earliest failure first):

lint  →  typecheck  →  unit  →  property  →  contract/schema  →  integration  →  e2e (if wired)

Run each present stage with the discovered command; capture and read its output and exit code:

run () { [ -z "$2" ] && { echo "── $1: skipped (no command) ──"; return; }; echo "── $1 ──"; eval "$2"; rc=$?; echo "exit=$rc"; [ $rc -eq 0 ] || { echo "RED at: $1"; exit $rc; }; }
run lint        "$LINT"
run typecheck   "$TYPECHECK"
run tests       "$TEST"          # unit + property + contract + integration per TESTING.md Tier B
run e2e         "$E2E"           # only if configured
  • Property tests are what makes the suite total rather than partial — they generate empty, boundary, malformed and adversarial inputs. If the suite has none for a function with a stateable law, flag it as a gap.
  • Generative paths (if any): confirm the critic/fallback path is exercised (e.g. FORCE_DEGRADE=1) — ground, generate, verify, degrade — with the fallback actually run.

Step 3 — Report the verdict (honest, evidence-based)

  • All green: report each stage with its real result (exit=0), state Tier-B is green, and that it is safe to commit. Only now may a todo item's → verify: be marked passed.
  • Any red: report the earliest failing stage with its real output — the failing assertion, the error — and stop there. Do not continue the battery and do not commit. Fix the earliest failure first; a later stage failing because an earlier one did is noise, not a second problem.
  • Skipped stages: name them explicitly (integration: skipped — no Docker) — a skipped check is never a passed check.

Hard rules (stop if you catch yourself doing these)

  • Claiming "tests pass" / "it's green" without having run the command and read exit=0. → run it; read it.
  • Committing, or telling the user to commit, on a red or partially-run gate. → block.
  • Reading, cat-ing, echoing, or pasting .env or any secret or log value. → presence-test only.
  • Pointing integration tests at a real/shared database instead of ephemeral Docker infra. → compose up/down.
  • Leaving infra running after a failure. → the trap … down -v tears it down on every exit.
  • Marking a todo item verified off a fast run. → only a green full Tier-B run justifies it.

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most quality gates skills give

Counted across 1,524 of the 2,830 authors here whose files we hold, read 2026-09-06

  • Read full output and check exit codein 45 of 1524, across 40 files
  • Verify output confirms the claimin 44 of 1524, across 39 files
  • Identify the command that proves the claimin 43 of 1524, across 39 files
  • Execute the full verification commandin 36 of 1524, across 30 files
  • Produce a verification reportin 34 of 1524, across 18 files
  • Review git diff changesin 30 of 1524, across 16 files
  • Fix build failures immediatelyin 29 of 1524, across 9 files
  • Group findings by severityin 28 of 1524
  • State claim only with evidencein 27 of 1524, across 22 files
  • Verify regression tests with red-green cyclein 26 of 1524, across 22 files
  • Run the full test suitein 26 of 1524, across 25 files
  • Run test suite with coveragein 25 of 1524, across 10 files

Said here and by no other author read

  • Read CLAUDE.md and TESTING.md to discover commands
  • Run lint, typecheck, unit, property, contract, integration, and e2e stages
  • Use docker compose to bring up ephemeral infra
  • Tear down infra using trap on exit
  • Report each stage result and exit code
  • Verify presence of environment variables without printing values

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.

Keep looking

Skills are one crate of 611,884. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.