test: improve ESM loader regression coverage

Assisted-by: Codex
Signed-off-by: Geoffrey Booth <webadmin@geoffreybooth.com>

Author: GeoffreyBooth

test/es-module/test-esm-cjs-named-error-entrypoint.mjs

@@ -0,0 +1,21 @@
+import '../common/index.mjs';
+import { spawnSyncAndAssert } from '../common/child_process.js';
+import * as fixtures from '../common/fixtures.mjs';
+import assert from 'assert';
+
+const entryPoint = fixtures.path('es-modules', 'package-cjs-named-error', 'single-quote.mjs');
+spawnSyncAndAssert(process.execPath, [entryPoint], {
+  status: 1,
+  stderr(stderr) {
+    assert(stderr.includes("Named export 'comeOn' not found."),
+           'entry point should show the missing named export');
+    assert(stderr.includes('CommonJS modules can always be imported via the default export'),
+           'entry point should show the CommonJS named export hint');
+    assert(stderr.includes("import pkg from './fail.cjs';"),
+           'entry point hint should recommend the default import');
+    assert(stderr.includes('const { comeOn } = pkg;'),
+           'entry point hint should show the named import as destructuring');
+    assert(stderr.includes("import { comeOn } from './fail.cjs';"),
+           'entry point error should include the source import statement');
+  },
+});

test/es-module/test-esm-cjs-named-error.mjs

@@ -1,7 +1,5 @@
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
+import '../common/index.mjs';
 import assert from 'assert';
-import { execPath } from 'node:process';
 
 const fixtureBase = '../fixtures/es-modules/package-cjs-named-error';
 
@@ -77,17 +75,3 @@ await assert.rejects(async () => {
 await assert.rejects(async () => {
   await import(`${fixtureBase}/escaped-single-quote.mjs`);
 }, /import pkg from '\.\/oh'no\.cjs'/, 'should support relative specifiers with escaped single quote');
-
-const entryPoint = fixtures.path('es-modules', 'package-cjs-named-error', 'single-quote.mjs');
-const { code, stderr } = await spawnPromisified(execPath, [entryPoint]);
-assert.strictEqual(code, 1);
-assert.ok(stderr.includes("Named export 'comeOn' not found."),
-          'entry point should show the missing named export');
-assert.ok(stderr.includes('CommonJS modules can always be imported via the default export'),
-          'entry point should show the CommonJS named export hint');
-assert.ok(stderr.includes("import pkg from './fail.cjs';"),
-          'entry point hint should recommend the default import');
-assert.ok(stderr.includes('const { comeOn } = pkg;'),
-          'entry point hint should show the named import as destructuring');
-assert.ok(stderr.includes("import { comeOn } from './fail.cjs';"),
-          'entry point error should include the source import statement');

test/es-module/test-esm-sync-import.mjs

@@ -1,52 +1,40 @@
 // Flags: --no-warnings
-import { spawnPromisified } from '../common/index.mjs';
+import '../common/index.mjs';
+import { spawnSyncAndAssert } from '../common/child_process.js';
 import * as fixtures from '../common/fixtures.mjs';
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
 
+// Promise counts are implementation details tracked for regressions, not API guarantees.
 
 describe('synchronous ESM loading', () => {
   it('should create minimal promises for ESM importing ESM', async () => {
-    // import-esm.mjs imports imported-esm.mjs — a pure ESM graph.
-    const count = await getPromiseCount(fixtures.path('es-modules', 'import-esm.mjs'));
-    // V8's Module::Evaluate returns one promise for the entire graph.
+    const count = getPromiseCount(fixtures.path('es-modules', 'import-esm.mjs'));
     assert.strictEqual(count, 1);
   });
 
   it('should create minimal promises for ESM importing CJS', async () => {
-    // builtin-imports-case.mjs imports node:assert (builtin) + dep1.js and dep2.js (CJS).
-    const count = await getPromiseCount(fixtures.path('es-modules', 'builtin-imports-case.mjs'));
-    // V8 creates one promise for the ESM entry evaluation, plus one per CJS module
-    // in the graph (each CJS namespace is wrapped in a promise).
-    // entry (ESM, 1) + node:assert (CJS, 1) + dep1.js (CJS, 1) + dep2.js (CJS, 1) = 4.
+    const count = getPromiseCount(fixtures.path('es-modules', 'builtin-imports-case.mjs'));
     assert.strictEqual(count, 4);
   });
 
   it('should fall back to async evaluation for top-level await', async () => {
-    // tla/resolved.mjs uses top-level await, so the sync path detects TLA
-    // and falls back to async evaluation.
-    const count = await getPromiseCount(fixtures.path('es-modules', 'tla', 'resolved.mjs'));
-    // The async fallback creates more promises — just verify the module
-    // still runs successfully. The promise count will be higher than the
-    // sync path but should remain bounded.
+    const count = getPromiseCount(fixtures.path('es-modules', 'tla', 'resolved.mjs'));
     assert(count > 1, `Expected TLA fallback to create multiple promises, got ${count}`);
   });
 
   it('should create minimal promises when entry point is CJS importing ESM', async () => {
-    // When a CJS entry point uses require(esm), the ESM module is loaded via
-    // ModuleJobSync, so the same promise minimization applies.
-    const count = await getPromiseCount(fixtures.path('es-modules', 'require-esm-entry.cjs'));
-    // V8's Module::Evaluate returns one promise for the ESM module.
+    const count = getPromiseCount(fixtures.path('es-modules', 'require-esm-entry.cjs'));
     assert.strictEqual(count, 1);
   });
 });
 
-
-async function getPromiseCount(entry) {
-  const { stdout, stderr, code } = await spawnPromisified(process.execPath, [
+function getPromiseCount(entry) {
+  const { stderr } = spawnSyncAndAssert(process.execPath, [
     '--trace-promises',
     entry,
-  ]);
-  assert.strictEqual(code, 0, `child failed:\nstdout: ${stdout}\nstderr: ${stderr}`);
+  ], {
+    stderr: /created promise #/,
+  });
   return stderr.match(/created promise #/g)?.length ?? 0;
 }

test/parallel/test-inspector-debug-brk-flag-esm-tla.js

@@ -18,9 +18,6 @@ async function testBreakpointOnStart(session) {
       'params': { 'state': 'none' } },
     { 'method': 'Debugger.setAsyncCallStackDepth',
       'params': { 'maxDepth': 0 } },
-    { 'method': 'Profiler.enable' },
-    { 'method': 'Profiler.setSamplingInterval',
-      'params': { 'interval': 100 } },
     { 'method': 'Debugger.setBlackboxPatterns',
       'params': { 'patterns': [] } },
     { 'method': 'Runtime.runIfWaitingForDebugger' },