gofront 1.8.0 → 1.9.1

package/src/cli/test-runner.js

@@ -6,7 +6,6 @@ import { statSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { HELPER_SPRINTF, HELPER_TESTING } from "../backend/js/runtime.js";
 import {
 	compilePackageTests,
 	compilePackageTestsWasm,
@@ -97,6 +96,19 @@ export function discoverTests(programs) {
 	return testNames;
 }
 
+// The `async func Test…` names (js packages only).
+export function discoverAsyncTests(programs) {
+	const names = [];
+	for (const p of programs) {
+		if (p._filename && !p._filename.endsWith("_test.go")) continue;
+		for (const d of p.decls) {
+			if (isTestFunc(d) && (d.async || d.isAsync) && !names.includes(d.name))
+				names.push(d.name);
+		}
+	}
+	return names;
+}
+
 export function discoverBenchmarks(programs) {
 	const benchNames = [];
 	for (const p of programs) {
@@ -120,15 +132,53 @@ export function discoverTestMain(programs) {
 	return null;
 }
 
-export function generateTestHarness(bundleJs, testNames, options = {}) {
-	const runRegex = options.run ? options.run : null;
-	const benchRegex = options.bench
-		? options.bench === true
-			? "."
-			: options.bench
-		: null;
-	const benchNames = options.benchNames ?? [];
-	const testMainName = options.testMain ?? null;
+// The Go source of the driver the runner compiles with a package's tests (see
+// `testDriver` in compileFiles; it is never written to disk). `target` is the
+// package's target: a `js` package is driven asynchronously so that async
+// tests and subtests can be awaited; a TestMain gets the M and runs it
+// itself.
+export function generateTestDriver(
+	pkgName,
+	target,
+	{ testNames, benchNames, testMain, asyncTests = [] },
+) {
+	if (testMain && asyncTests.length > 0) {
+		throw new Error(
+			`async test functions cannot be combined with TestMain (${asyncTests.join(", ")}): remove TestMain or make the tests synchronous`,
+		);
+	}
+	const entries = (names, _type) =>
+		names.map((n) => `\t\t{Name: ${JSON.stringify(n)}, F: ${n}},`).join("\n");
+	const table = (type, names) =>
+		names.length === 0
+			? `[]testing.${type}{}`
+			: `[]testing.${type}{\n${entries(names)}\n\t}`;
+	const make = `\tm := testing.GofrontMain(${JSON.stringify(pkgName)}, run, bench, verbose, ${table("GofrontTest", testNames)}, ${table("GofrontBenchmark", benchNames)})`;
+	let body;
+	let head = "func";
+	if (testMain) {
+		body = `\tTestMain(m)\n\treturn m.ExitCode()`;
+	} else if (target === "js") {
+		head = "async func";
+		body = "\treturn await m.RunAsync()";
+	} else {
+		body = "\treturn m.Run()";
+	}
+	return `package ${pkgName}
+
+import "testing"
+
+${head} GofrontRunTests(run, bench string, verbose bool) int {
+${make}
+${body}
+}
+`;
+}
+
+// The module the test child process runs: the compiled package (with its
+// driver), then one call to GofrontRunTests. Everything else (running,
+// filtering, reporting) happens inside the package.
+export function generateTestHarness(bundleJs, options = {}) {
 	const verbose = Boolean(options.verbose);
 	const dom = Boolean(options.dom);
 	const color = Boolean(options.color);
@@ -138,14 +188,12 @@ export function generateTestHarness(bundleJs, testNames, options = {}) {
 	const jsdomSpec = options.jsdomPath
 		? pathToFileURL(options.jsdomPath).href
 		: "jsdom";
-
-	const allFuncNames = [
-		...new Set([
-			...testNames,
-			...benchNames,
-			...(testMainName ? [testMainName] : []),
-		]),
-	];
+	const run = options.run ?? "";
+	const bench = options.bench
+		? options.bench === true
+			? "."
+			: options.bench
+		: "";
 
 	return `
 ${
@@ -177,14 +225,12 @@ globalThis.customElements = __dom.window.customElements;
 globalThis.document = globalThis.document ?? null;
 `
 }
-globalThis.__gofront_verbose = ${verbose};
+// The package line and colours the testing package prints come from here.
+process.env.GOFRONT_TEST_LABEL = ${JSON.stringify(pkgName)};
+process.env.GOFRONT_TEST_COLOR = ${color ? '"1"' : '"0"'};
 ${
 	options.wasmBytes
-		? `
-// ── WASM module (tests run inside app.wasm; *testing.T stays in JS) ──
-${HELPER_SPRINTF}
-${HELPER_TESTING}
-globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.from(options.wasmBytes).toString("base64"))}), (c) => c.charCodeAt(0));
+		? `globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.from(options.wasmBytes).toString("base64"))}), (c) => c.charCodeAt(0));
 `
 		: ""
 }
@@ -192,313 +238,13 @@ globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.f
 ${bundleJs}
 // ─────────────────────────────
 
-async function __runGoFrontSuite() {
-  const allTests = ${JSON.stringify(testNames)};
-  const allBenchmarks = ${JSON.stringify(benchNames)};
-  const testMainName = ${JSON.stringify(testMainName)};
-  const runFilter = ${runRegex ? `new RegExp(${JSON.stringify(runRegex)})` : "null"};
-  const benchFilter = ${benchRegex ? `new RegExp(${JSON.stringify(benchRegex)})` : "null"};
-  const verbose = ${verbose};
-  const pkgName = ${JSON.stringify(pkgName)};
-  const paint = ${color}
-    ? (code) => (s) => "\\x1b[" + code + "m" + s + "\\x1b[0m"
-    : () => (s) => s;
-  const red = paint(31), green = paint(32), yellow = paint(33), dim = paint(2), bold = paint(1);
-  const PASS = green("PASS"), FAIL = bold(red("FAIL")), SKIP = yellow("SKIP");
-  const okLine = (name, t) => console.log(green("ok  ") + "\\t" + name + "\\t" + dim(t + "s"));
-
-  const testsToRun = runFilter
-    ? allTests.filter((name) => runFilter.test(name))
-    : allTests;
-
-  const benchesToRun = benchFilter
-    ? allBenchmarks.filter((name) => benchFilter.test(name))
-    : [];
-
-  if (testsToRun.length === 0 && benchesToRun.length === 0) {
-    if (allTests.length > 0 && runFilter) {
-      console.log(yellow("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)}));
-    }
-    if (allBenchmarks.length > 0 && benchFilter) {
-      console.log(yellow("testing: warning: no benchmarks to run matching " + ${JSON.stringify(benchRegex)}));
-    }
-    console.log(PASS);
-    okLine(pkgName, "0.000");
-    process.exit(0);
-  }
-
-  const now = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
-
-  // Go-style streaming report. In non-verbose mode only failures and skips are
-  // shown, so the "=== RUN" header is emitted late for failures.
-  const report = (t) => {
-    const elapsed = dim("(" + ((now() - t._start) / 1000).toFixed(2) + "s)");
-    if (t.skipped) {
-      console.log("--- " + SKIP + ": " + t._name + " " + elapsed);
-      for (const log of t._logs) console.log("    " + log);
-    } else if (t.failed) {
-      if (!verbose) console.log(dim("=== RUN   ") + t._name);
-      for (const log of t._logs) console.log("    " + red(log));
-      console.log("--- " + FAIL + ": " + t._name + " " + elapsed);
-    } else if (verbose) {
-      for (const log of t._logs) console.log("    " + log);
-      console.log("--- " + PASS + ": " + t._name + " " + elapsed);
-    }
-  };
-
-  const reportBenchmark = (b) => {
-    if (b.skipped) {
-      console.log("--- " + SKIP + ": " + b._name);
-      for (const log of b._logs) console.log("    " + log);
-      return;
-    }
-    if (b.failed) {
-      console.log("--- " + FAIL + ": " + b._name);
-      for (const log of b._logs) console.log("    " + red(log));
-      return;
-    }
-    const elapsedNs = Number(b.Elapsed());
-    const nsPerOp = b.N > 0 ? (elapsedNs / b.N).toFixed(0) : "0";
-    let line = \`\${b._name.padEnd(20)}\\t\${String(b.N).padStart(8)}\\t\${nsPerOp.padStart(10)} ns/op\`;
-    if (b._bytes > 0n && elapsedNs > 0) {
-      const mbPerSec = (Number(b._bytes * BigInt(b.N)) / (elapsedNs / 1e9) / (1024 * 1024)).toFixed(2);
-      line += \`\\t\${mbPerSec.padStart(8)} MB/s\`;
-    }
-    console.log(line);
-    for (const log of b._logs) console.log("    " + log);
-  };
-
-  // FailNow/SkipNow are control flow; anything else is a panic → failure.
-  const recordTestError = (t, e) => {
-    if (e instanceof __GoFront_FailNow || e instanceof __GoFront_SkipNow) return;
-    t.Fail();
-    t.Log("panic: " + (e?.message ?? String(e)));
-  };
-
-  globalThis.__onSubtestStart = (name) => {
-    if (verbose) console.log(dim("=== RUN   ") + name);
-  };
-  globalThis.__onSubtestEnd = report;
-
-  const __testRegistry = {
-${allFuncNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ? ${n} : null`).join(",\n")}
-  };
-
-  function runAll() {
-    let totalFailures = 0;
-    let totalSkipped = 0;
-    const suiteStart = now();
-
-    const finish = () => {
-      const suiteElapsed = ((now() - suiteStart) / 1000).toFixed(3);
-      if (totalFailures > 0) {
-        console.log(FAIL);
-        console.log(FAIL + "\\t" + pkgName + "\\t" + dim(suiteElapsed + "s"));
-        return 1;
-      } else {
-        console.log(PASS);
-        okLine(pkgName, suiteElapsed);
-        return 0;
-      }
-    };
-
-    const runOneTest = (name) => {
-      const fn = __testRegistry[name] ?? (typeof globalThis[name] === "function" ? globalThis[name] : null);
-      if (typeof fn !== "function") {
-        console.error(red("testing: cannot find test function " + name));
-        totalFailures++;
-        return null;
-      }
-
-      const t = new __GoFront_T(name);
-      if (verbose) console.log(dim("=== RUN   ") + name);
-
-      let res;
-      try {
-        res = fn(t);
-      } catch (e) {
-        recordTestError(t, e);
-        t._runCleanups();
-        if (t.skipped) totalSkipped++;
-        else if (t.failed) totalFailures++;
-        report(t);
-        return null;
-      }
-
-      if (res && typeof res.then === "function") {
-        return res
-          .catch((e) => { recordTestError(t, e); })
-          .finally(() => {
-            t._runCleanups();
-            if (t.skipped) totalSkipped++;
-            else if (t.failed) totalFailures++;
-            report(t);
-          });
-      }
-
-      t._runCleanups();
-      if (t.skipped) totalSkipped++;
-      else if (t.failed) totalFailures++;
-      report(t);
-      return null;
-    };
-
-    const runOneBench = (name) => {
-      const fn = __testRegistry[name] ?? (typeof globalThis[name] === "function" ? globalThis[name] : null);
-      if (typeof fn !== "function") {
-        console.error(red("testing: cannot find benchmark function " + name));
-        totalFailures++;
-        return null;
-      }
-      if (verbose) console.log(dim("=== RUN   ") + name);
-      const b = new __GoFront_B(name);
-      b._benchDurationNs = 1e8; // 100ms
-      const runIters = () => {
-        b.N = 1;
-        b.ResetTimer();
-        const res = fn(b);
-        if (res && typeof res.then === "function") {
-          return res.then(() => loopBench(b, fn));
-        }
-        return loopBench(b, fn);
-      };
-      const loopBench = (b, fn) => {
-        if (!b._loopStarted && !b.failed && !b.skipped) {
-          b.StopTimer();
-          b._runCleanups();
-          let n = 1;
-          while (!b.failed && !b.skipped) {
-            const elapsedNs = Number(b.Elapsed());
-            if (elapsedNs >= b._benchDurationNs || n >= 1e9) break;
-            let nextN;
-            if (elapsedNs === 0) nextN = n * 100;
-            else nextN = Math.max(n + 1, Math.min(1e9, Math.floor(n * (b._benchDurationNs / elapsedNs) * 1.2)));
-            if (nextN <= n) break;
-            n = nextN;
-            const nextB = new __GoFront_B(name);
-            nextB._benchDurationNs = b._benchDurationNs;
-            nextB.N = n;
-            nextB.ResetTimer();
-            const res = fn(nextB);
-            if (res && typeof res.then === "function") {
-              return res.then(() => {
-                nextB.StopTimer();
-                nextB._runCleanups();
-                b.N = nextB.N;
-                b._elapsedMs = nextB._elapsedMs;
-                b._timerRunning = false;
-                b.failed = nextB.failed;
-                b.skipped = nextB.skipped;
-                b._logs = nextB._logs;
-              });
-            }
-            nextB.StopTimer();
-            nextB._runCleanups();
-            b.N = nextB.N;
-            b._elapsedMs = nextB._elapsedMs;
-            b._timerRunning = false;
-            b.failed = nextB.failed;
-            b.skipped = nextB.skipped;
-            b._logs = nextB._logs;
-          }
-        }
-      };
-
-      let res;
-      try {
-        res = runIters();
-      } catch (e) {
-        recordTestError(b, e);
-        b._runCleanups();
-        if (b.failed) totalFailures++;
-        else if (b.skipped) totalSkipped++;
-        reportBenchmark(b);
-        return null;
-      }
-
-      if (res && typeof res.then === "function") {
-        return res
-          .catch((e) => { recordTestError(b, e); })
-          .finally(() => {
-            b._runCleanups();
-            if (b.failed) totalFailures++;
-            else if (b.skipped) totalSkipped++;
-            reportBenchmark(b);
-          });
-      }
-
-      b._runCleanups();
-      if (b.failed) totalFailures++;
-      else if (b.skipped) totalSkipped++;
-      reportBenchmark(b);
-      return null;
-    };
-
-    let ti = 0;
-    while (ti < testsToRun.length) {
-      const p = runOneTest(testsToRun[ti++]);
-      if (p) {
-        return p.then(async () => {
-          while (ti < testsToRun.length) {
-            const nextP = runOneTest(testsToRun[ti++]);
-            if (nextP) await nextP;
-          }
-          for (const bName of benchesToRun) {
-            const nextP = runOneBench(bName);
-            if (nextP) await nextP;
-          }
-          return finish();
-        });
-      }
-    }
-
-    let bi = 0;
-    while (bi < benchesToRun.length) {
-      const p = runOneBench(benchesToRun[bi++]);
-      if (p) {
-        return p.then(async () => {
-          while (bi < benchesToRun.length) {
-            const nextP = runOneBench(benchesToRun[bi++]);
-            if (nextP) await nextP;
-          }
-          return finish();
-        });
-      }
-    }
-
-    return finish();
-  }
-
-  if (testMainName) {
-    const mainFn = __testRegistry[testMainName] ?? (typeof globalThis[testMainName] === "function" ? globalThis[testMainName] : null);
-    if (typeof mainFn === "function") {
-      let exitCode = 0;
-      const m = new __GoFront_M(() => {
-        const res = runAll();
-        if (res && typeof res.then === "function") {
-          return res.then((code) => { exitCode = code; return code; });
-        }
-        exitCode = res;
-        return exitCode;
-      });
-      try {
-        const res = mainFn(m);
-        if (res && typeof res.then === "function") await res;
-      } catch (e) {
-        console.error(red("panic in TestMain: " + (e?.message ?? String(e))));
-        process.exit(1);
-      }
-      if (m._promise) await m._promise;
-      process.exit(exitCode);
-    }
-  }
-
-  const res = runAll();
-  const exitCode = res && typeof res.then === "function" ? await res : res;
-  process.exit(exitCode);
+let __exitCode = 1;
+try {
+  __exitCode = Number(await GofrontRunTests(${JSON.stringify(run)}, ${JSON.stringify(bench)}, ${verbose}));
+} catch (e) {
+  console.error("panic: " + (e?.message ?? String(e)));
 }
-
-__runGoFrontSuite();
+process.exit(__exitCode);
 `;
 }
 
@@ -613,10 +359,16 @@ function reportBuildFailure(err, resolvedDir, options) {
 
 // `both` packages run twice (JS and wasm) so the two backends are kept in
 // agreement; output of both runs is concatenated.
-async function runDualTarget(compiled, resolvedDir, runHarness, options) {
+async function runDualTarget(
+	compiled,
+	resolvedDir,
+	runHarness,
+	compileOptions,
+	options,
+) {
 	let wasmCompiled;
 	try {
-		wasmCompiled = compilePackageTestsWasm(resolvedDir, options);
+		wasmCompiled = compilePackageTestsWasm(resolvedDir, compileOptions);
 	} catch (err) {
 		return reportBuildFailure(err, resolvedDir, options);
 	}
@@ -654,18 +406,35 @@ export async function runTests(targetDir, options = {}) {
 		return reportEmptyTests(basename(resolvedDir), "no test files", options);
 	}
 
+	// The driver is generated while the package compiles, once its files are
+	// parsed and its target is known.
+	let testNames = [];
+	let benchNames = [];
+	let testMain = null;
+	const compileOptions = {
+		...options,
+		testDriver: (programs, target) => {
+			testNames = discoverTests(programs);
+			benchNames = discoverBenchmarks(programs);
+			testMain = discoverTestMain(programs);
+			if (testNames.length === 0 && benchNames.length === 0 && !testMain)
+				return null;
+			return generateTestDriver(programs[0].pkg.name, target, {
+				testNames,
+				benchNames,
+				testMain,
+				asyncTests: discoverAsyncTests(programs),
+			});
+		},
+	};
 	let compiled;
 	try {
-		compiled = compilePackageTests(resolvedDir, options);
+		compiled = compilePackageTests(resolvedDir, compileOptions);
 	} catch (err) {
 		return reportBuildFailure(err, resolvedDir, options);
 	}
 
-	const { pkgName, js, programs } = compiled;
-	const testNames = discoverTests(programs);
-	const benchNames = discoverBenchmarks(programs);
-	const testMain = discoverTestMain(programs);
-
+	const { pkgName, js } = compiled;
 	if (testNames.length === 0 && benchNames.length === 0 && !testMain) {
 		return reportEmptyTests(pkgName, "no tests to run", options);
 	}
@@ -673,10 +442,8 @@ export async function runTests(targetDir, options = {}) {
 	const runHarness = (bundleJs, label, wasmBytes) =>
 		spawnTestRunner(
 			resolvedDir,
-			generateTestHarness(bundleJs, testNames, {
+			generateTestHarness(bundleJs, {
 				...options,
-				benchNames,
-				testMain,
 				pkgName: label,
 				jsdomPath,
 				wasmBytes,
@@ -696,7 +463,13 @@ export async function runTests(targetDir, options = {}) {
 		}
 	}
 	if (compiled.target === "both") {
-		return runDualTarget(compiled, resolvedDir, runHarness, options);
+		return runDualTarget(
+			compiled,
+			resolvedDir,
+			runHarness,
+			compileOptions,
+			options,
+		);
 	}
 	return runHarness(js, pkgName, compiled.wasm ?? null);
 }