test(infra): legacy-test-runner supports this.skip() and Promise-returning tests

Two improvements to scripts/legacy-test-runner.js needed for the new
runtime-conditional GHSA tests:

1. `this.skip()` — Mocha exposes runtime-conditional skipping via the
   test context. The runner now provides a `skip()` method that throws
   a sentinel value, recognised by `testCompleted` and reported as
   pending (not failed).

2. Async tests without a `done` callback. Previously the runner only
   handled `done`-style async (length > 0) and assumed length-0 tests
   were sync. Promise-returning length-0 tests (`async function () {}`)
   detached and any rejection became `UnhandledPromiseRejection`. Now
   the sync path detects a thenable return and routes the resolution /
   rejection through `testCompleted`.

Author: patriksimek

scripts/legacy-test-runner.js

@@ -122,7 +122,10 @@ function next() {
 	}
 
 	const testCompleted = error => {
-		if (error) {
+		if (error === SKIP_SENTINEL) {
+			console.log('    - ' + currentTest.name);
+			counterPending++;
+		} else if (error) {
 			console.log('    ✘ ' + currentTest.name);
 			hasError = true;
 			counterFailed++;
@@ -136,10 +139,17 @@ function next() {
 
 	// Mocha exposes `this.timeout(ms)` inside it() callbacks too. Provide a
 	// stub so tests don't blow up; we don't enforce real timeouts here.
+	// Mocha exposes `this.skip()` inside it() callbacks for runtime-conditional
+	// skipping. Throw a sentinel that we recognize as "skip" rather than a
+	// real failure.
+	const SKIP_SENTINEL = {};
 	const ctx = {
 		timeout(ms) {
 			currentTest.timeoutMs = ms;
 		},
+		skip() {
+			throw SKIP_SENTINEL;
+		},
 	};
 	try {
 		if (currentGroup.beforeEach) {
@@ -148,7 +158,7 @@ function next() {
 			}
 		}
 		if (currentTest.fn.length) {
-			// Async test
+			// Async test (done-callback style)
 			currentTest.fn.call(ctx, error => {
 				if (!error && currentGroup.afterEach) {
 					try {
@@ -162,14 +172,33 @@ function next() {
 				testCompleted(error);
 			});
 		} else {
-			// Sync test
-			currentTest.fn.call(ctx);
-			if (currentGroup.afterEach) {
-				for (let i = 0; i < currentGroup.afterEach.length; i++) {
-					currentGroup.afterEach[i].call(ctx);
+			// Sync test or Promise-returning async test
+			const ret = currentTest.fn.call(ctx);
+			if (ret && typeof ret.then === 'function') {
+				// Promise-returning test (e.g. async function ()).
+				ret.then(
+					() => {
+						if (currentGroup.afterEach) {
+							try {
+								for (let i = 0; i < currentGroup.afterEach.length; i++) {
+									currentGroup.afterEach[i].call(ctx);
+								}
+							} catch (e) {
+								return testCompleted(e);
+							}
+						}
+						testCompleted();
+					},
+					err => testCompleted(err),
+				);
+			} else {
+				if (currentGroup.afterEach) {
+					for (let i = 0; i < currentGroup.afterEach.length; i++) {
+						currentGroup.afterEach[i].call(ctx);
+					}
 				}
+				testCompleted();
 			}
-			testCompleted();
 		}
 	} catch (error) {
 		testCompleted(error);