#!/usr/bin/env bun /** * TEST-ONLY resilient runner for the live API suite. * * Why this exists * --------------- * The whole suite in one jest process keeps one `wrangler dev` (workerd) * instance alive for ~13-15 minutes. On a large local D1 that instance can hit * V8's heap limit ("V8 fatal error ... Reached heap limit"), after which every * remaining suite fails with "fetch failed". * * This runner: * - splits the test files into chunks (default 10, round-robin by file size), * - runs each chunk with `jest --runInBand`, * - restarts the backend between chunks (resetting the workerd heap), * - starts the backend if it is down, and fails fast if it cannot start. * * Seeds/D1 state persist across restarts. `tests/global-setup.ts` still runs per * chunk and clears the KV order tracker. * * Usage (from apps/backend): * bun run test:api:all * CHUNK_SIZE=8 bun run test:api:all */ import { spawnSync } from 'node:child_process' import { readdirSync, statSync } from 'node:fs' import os from 'node:os' import path from 'node:path' const BACKEND_DIR = path.resolve(process.cwd()) const API_BASE_URL = (process.env.API_BASE_URL ?? 'http://localhost:8787').replace(/\/+$/, '') const CHUNK_SIZE = Math.max(1, Number(process.env.CHUNK_SIZE ?? 10)) const SERVER_LOG = path.join(os.tmpdir(), 'freshyo-wrangler-run-all.log') function listTests(): string[] { const api = readdirSync(path.join(BACKEND_DIR, 'tests/api')) .filter((file) => file.endsWith('.test.ts')) .map((file) => `tests/api/${file}`) const unit = readdirSync(path.join(BACKEND_DIR, 'tests/unit')) .filter((file) => file.endsWith('.test.ts')) .map((file) => `tests/unit/${file}`) // Round-robin by file size so the slow suites are spread across chunks. const bySize = [...api, ...unit].sort( (a, b) => statSync(path.join(BACKEND_DIR, b)).size - statSync(path.join(BACKEND_DIR, a)).size ) const chunks: string[][] = Array.from({ length: Math.ceil(bySize.length / CHUNK_SIZE) }, () => []) bySize.forEach((file, index) => chunks[index % chunks.length].push(file)) return chunks.flat() } async function healthy(): Promise { try { const res = await fetch(`${API_BASE_URL}/api/health`, { signal: AbortSignal.timeout(2_000) }) return res.ok } catch { return false } } function killBackend(): void { // Whatever is listening on 8787 (the backend workerd/wrangler). const lsof = spawnSync('lsof', ['-ti', 'tcp:8787'], { encoding: 'utf8' }) for (const pid of (lsof.stdout ?? '').split(/\s+/).filter(Boolean)) { try { process.kill(Number(pid), 'SIGTERM') } catch { /* already gone */ } } // Backend wrangler supervisor (never touch other apps' wrangler processes). const ps = spawnSync( 'bash', [ '-lc', "ps aux | grep 'wrangler-dist/cli.js dev' | grep 'apps/backend' | grep -v grep | awk '{print $2}'", ], { encoding: 'utf8' } ) for (const pid of (ps.stdout ?? '').split(/\s+/).filter(Boolean)) { try { process.kill(Number(pid), 'SIGTERM') } catch { /* already gone */ } } } async function waitForHealth(timeoutMs = 60_000): Promise { const deadline = Date.now() + timeoutMs while (Date.now() < deadline) { if (await healthy()) return true await new Promise((resolve) => setTimeout(resolve, 1_000)) } return false } async function startBackend(): Promise { console.log(`[run-all] starting backend (log: ${SERVER_LOG})`) spawnSync('bash', ['-lc', `cd ${JSON.stringify(BACKEND_DIR)} && nohup bun run dev > ${JSON.stringify(SERVER_LOG)} 2>&1 &`], { stdio: 'ignore', }) if (!(await waitForHealth())) { throw new Error(`[run-all] backend did not become healthy at ${API_BASE_URL}`) } } async function restartBackend(): Promise { console.log('[run-all] restarting backend to reset the workerd heap…') killBackend() await new Promise((resolve) => setTimeout(resolve, 2_000)) await startBackend() } async function main(): Promise { const files = listTests() const chunks: string[][] = [] for (let i = 0; i < files.length; i += CHUNK_SIZE) chunks.push(files.slice(i, i + CHUNK_SIZE)) console.log(`[run-all] ${files.length} files in ${chunks.length} chunks of <=${CHUNK_SIZE}`) if (!(await healthy())) await startBackend() const results: Array<{ chunk: number; files: number; code: number | null }> = [] for (let i = 0; i < chunks.length; i += 1) { console.log(`\n[run-all] ===== chunk ${i + 1}/${chunks.length} (${chunks[i].length} files) =====`) const run = spawnSync( 'bunx', ['jest', '--config', 'tests/jest.config.js', '--runInBand', ...chunks[i]], { cwd: BACKEND_DIR, stdio: 'inherit' } ) results.push({ chunk: i + 1, files: chunks[i].length, code: run.status }) if (i < chunks.length - 1) await restartBackend() } console.log('\n[run-all] summary') for (const result of results) { console.log(` chunk ${result.chunk}: ${result.code === 0 ? 'PASS' : `FAIL (exit ${result.code})`} (${result.files} files)`) } const failed = results.filter((result) => result.code !== 0) console.log(` ${results.length - failed.length}/${results.length} chunks passed`) process.exit(failed.length === 0 ? 0 : 1) } main().catch((error) => { console.error('[run-all] failed:', error) process.exit(1) })