gofront 1.7.0 → 1.9.0

package/src/{test-runner.js → cli/test-runner.js}

@@ -6,13 +6,12 @@ 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 { colorEnabled, createColors, formatDiagnostic } from "./colors.js";
 import {
 	compilePackageTests,
 	compilePackageTestsWasm,
 	gwFilesIn,
-} from "./compiler.js";
+} from "../compiler.js";
+import { colorEnabled, createColors, formatDiagnostic } from "./colors.js";
 
 // WasmGC + exception handling (what the wasm backend emits) ship enabled by
 // default from Node 22 (V8 11.9+). Older runtimes fail at instantiate time
@@ -30,11 +29,55 @@ export function checkWasmRuntime(version = process.version) {
 export function isTestFunc(decl) {
 	if (decl.kind !== "FuncDecl") return false;
 	if (!decl.name.startsWith("Test")) return false;
+	if (decl.name === "TestMain") return false;
+	if (decl.params?.length !== 1) return false;
+	const pType = decl.params[0].type;
+	if (
+		pType?.kind === "PointerType" &&
+		(pType.base?.name === "testing.T" || pType.base?.name === "T")
+	)
+		return true;
+	if (
+		pType?.kind === "TypeName" &&
+		(pType.name === "testing.T" || pType.name === "T")
+	)
+		return true;
+	return false;
+}
+
+export function isBenchmarkFunc(decl) {
+	if (decl.kind !== "FuncDecl") return false;
+	if (!decl.name.startsWith("Benchmark")) return false;
+	if (decl.params?.length !== 1) return false;
+	const pType = decl.params[0].type;
+	if (
+		pType?.kind === "PointerType" &&
+		(pType.base?.name === "testing.B" || pType.base?.name === "B")
+	)
+		return true;
+	if (
+		pType?.kind === "TypeName" &&
+		(pType.name === "testing.B" || pType.name === "B")
+	)
+		return true;
+	return false;
+}
+
+export function isTestMainFunc(decl) {
+	if (decl.kind !== "FuncDecl") return false;
+	if (decl.name !== "TestMain") return false;
 	if (decl.params?.length !== 1) return false;
 	const pType = decl.params[0].type;
-	if (pType?.kind === "PointerType" && pType.base?.name === "testing.T")
+	if (
+		pType?.kind === "PointerType" &&
+		(pType.base?.name === "testing.M" || pType.base?.name === "M")
+	)
+		return true;
+	if (
+		pType?.kind === "TypeName" &&
+		(pType.name === "testing.M" || pType.name === "M")
+	)
 		return true;
-	if (pType?.kind === "TypeName" && pType.name === "testing.T") return true;
 	return false;
 }
 
@@ -53,8 +96,89 @@ export function discoverTests(programs) {
 	return testNames;
 }
 
-export function generateTestHarness(bundleJs, testNames, options = {}) {
-	const runRegex = options.run ? options.run : null;
+// 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) {
+		if (p._filename && !p._filename.endsWith("_test.go")) continue;
+		for (const d of p.decls) {
+			if (isBenchmarkFunc(d) && !benchNames.includes(d.name)) {
+				benchNames.push(d.name);
+			}
+		}
+	}
+	return benchNames;
+}
+
+export function discoverTestMain(programs) {
+	for (const p of programs) {
+		if (p._filename && !p._filename.endsWith("_test.go")) continue;
+		for (const d of p.decls) {
+			if (isTestMainFunc(d)) return d.name;
+		}
+	}
+	return 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);
@@ -64,6 +188,12 @@ export function generateTestHarness(bundleJs, testNames, options = {}) {
 	const jsdomSpec = options.jsdomPath
 		? pathToFileURL(options.jsdomPath).href
 		: "jsdom";
+	const run = options.run ?? "";
+	const bench = options.bench
+		? options.bench === true
+			? "."
+			: options.bench
+		: "";
 
 	return `
 ${
@@ -95,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));
 `
 		: ""
 }
@@ -110,106 +238,13 @@ globalThis.__GOFRONT_WASM_BYTES = Uint8Array.from(atob(${JSON.stringify(Buffer.f
 ${bundleJs}
 // ─────────────────────────────
 
-async function __runGoFrontSuite() {
-  const allTests = ${JSON.stringify(testNames)};
-  const runFilter = ${runRegex ? `new RegExp(${JSON.stringify(runRegex)})` : "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;
-
-  if (testsToRun.length === 0) {
-    if (allTests.length > 0 && runFilter) {
-      console.log(yellow("testing: warning: no tests to run matching " + ${JSON.stringify(runRegex)}));
-    }
-    console.log(PASS);
-    okLine(pkgName, "0.000");
-    process.exit(0);
-  }
-
-  let totalFailures = 0;
-  let totalSkipped = 0;
-  const now = () => (typeof performance !== "undefined" ? performance.now() : Date.now());
-  const suiteStart = 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);
-    }
-  };
-
-  // 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 = {
-${testNames.map((n) => `    ${JSON.stringify(n)}: typeof ${n} !== "undefined" ? ${n} : null`).join(",\n")}
-  };
-
-  for (const name of testsToRun) {
-    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++;
-      continue;
-    }
-
-    const t = new __GoFront_T(name);
-    if (verbose) console.log(dim("=== RUN   ") + name);
-
-    try {
-      const res = fn(t);
-      if (res && typeof res.then === "function") await res;
-    } catch (e) {
-      recordTestError(t, e);
-    }
-
-    if (t.skipped) totalSkipped++;
-    else if (t.failed) totalFailures++;
-    report(t);
-  }
-
-  const suiteElapsed = ((now() - suiteStart) / 1000).toFixed(3);
-
-  if (totalFailures > 0) {
-    console.log(FAIL);
-    console.log(FAIL + "\\t" + pkgName + "\\t" + dim(suiteElapsed + "s"));
-    process.exit(1);
-  } else {
-    console.log(PASS);
-    okLine(pkgName, suiteElapsed);
-    process.exit(0);
-  }
+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);
 `;
 }
 
@@ -324,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);
 	}
@@ -365,31 +406,50 @@ 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);
-
-	if (testNames.length === 0) {
+	const { pkgName, js } = compiled;
+	if (testNames.length === 0 && benchNames.length === 0 && !testMain) {
 		return reportEmptyTests(pkgName, "no tests to run", options);
 	}
 
 	const runHarness = (bundleJs, label, wasmBytes) =>
 		spawnTestRunner(
 			resolvedDir,
-			generateTestHarness(bundleJs, testNames, {
+			generateTestHarness(bundleJs, {
 				...options,
 				pkgName: label,
 				jsdomPath,
 				wasmBytes,
 				color: colorsFor(options, options.stdout ?? process.stdout).enabled,
 			}),
-			testNames.length,
+			testNames.length + benchNames.length,
 			options,
 		);
 
@@ -403,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);
 }

package/src/{vendor.js → cli/vendor.js}

@@ -442,10 +442,9 @@ export async function bundleVendor(projectDir = ".", options = {}) {
 	}
 
 	const entryCode = generateVendorEntry(packages, globals, namedExports);
-	const entryFile = join(
-		projectRoot,
-		`.gofront-vendor-entry-${Date.now()}.mjs`,
-	);
+	// A fixed name: the bundler records the entry path in vendor.js, so a
+	// per-run name would make every prep produce different bytes.
+	const entryFile = join(projectRoot, ".gofront-vendor-entry.mjs");
 	writeFileSync(entryFile, entryCode);
 
 	try {