WIP fix tests for off-thread loader

Author: cspotcode

ava.config.cjs

@@ -16,7 +16,7 @@ module.exports = {
     CONCURRENT_TESTS: '4'
   },
   require: ['./src/test/remove-env-var-force-color.js'],
-  nodeArguments: ['--loader', './src/test/test-loader.mjs', '--no-warnings'],
+  nodeArguments: ['--loader', './src/test/test-loader/loader.mjs', '--no-warnings'],
   timeout: '300s',
   concurrency: 4,
   // We do chdir -- maybe other things -- that you can't do in worker_threads.

src/test/helpers/ctx-ts-node.ts

@@ -11,8 +11,10 @@ import { testsDirRequire, tsNodeTypes } from './misc';
 /** Pass to `test.context()` to get access to the ts-node API under test */
 export async function ctxTsNode() {
   await installTsNode();
+  const tsNodeSpecifier = testsDirRequire.resolve('ts-node');
   const tsNodeUnderTest: typeof tsNodeTypes = testsDirRequire('ts-node');
   return {
+    tsNodeSpecifier,
     tsNodeUnderTest,
   };
 }

src/test/helpers/reset-node-environment.ts

@@ -1,4 +1,5 @@
 import { has, mapValues, sortBy } from 'lodash';
+import * as testLoader from '../test-loader/client';
 
 // Reset node environment
 // Useful because ts-node installation necessarily must mutate the node environment.
@@ -44,7 +45,7 @@ export function resetNodeEnvironment() {
   resetObject(global, defaultGlobal, ['__coverage__']);
 
   // Reset our ESM hooks
-  process.__test_setloader__?.(undefined);
+  testLoader.clearLoader();
 }
 
 function captureObjectState(object: any, avoidGetters: string[] = []) {

src/test/repl/repl.spec.ts

@@ -222,8 +222,8 @@ test.suite('top level await', ({ contextEach }) => {
   });
 
   test('should pass upstream test cases', async (t) => {
-    const { tsNodeUnderTest } = t.context;
-    await upstreamTopLevelAwaitTests({ TEST_DIR, tsNodeUnderTest });
+    const { tsNodeUnderTest, tsNodeSpecifier } = t.context;
+    await upstreamTopLevelAwaitTests({ TEST_DIR, tsNodeUnderTest, tsNodeSpecifier });
   });
 });
 

src/test/resolver.spec.ts

@@ -13,9 +13,10 @@ import * as semver from 'semver';
 import { padStart } from 'lodash';
 import _ = require('lodash');
 import { pathToFileURL } from 'url';
-import type { RegisterOptions } from '..';
+import type { CreateOptions, RegisterOptions } from '..';
 import * as fs from 'fs';
 import * as Path from 'path';
+import * as testLoader from './test-loader/client';
 
 /*
  * Each test case is a separate TS project, with a different permutation of
@@ -660,10 +661,11 @@ async function execute(t: T, p: FsProject, entrypoints: Entrypoint[]) {
   // Install ts-node and try to import all the index-* files
   //
 
-  const service = t.context.tsNodeUnderTest.register({
+  const options: CreateOptions = {
     projectSearchDir: p.cwd,
-  });
-  process.__test_setloader__(t.context.tsNodeUnderTest.createEsmHooks(service));
+  };
+  t.context.tsNodeUnderTest.register(options);
+  await testLoader.setLoader(t.context.tsNodeSpecifier, options);
 
   for (const entrypoint of entrypoints) {
     t.log(`Importing ${join(p.cwd, entrypoint)}`);

src/test/test-loader.d.ts

@@ -0,0 +1,11 @@
+An injectable --loader used by tests. It allows tests to setup and teardown
+different loader behaviors in-process.
+
+By default, it does nothing, as if we were not using a loader at all. But it
+responds to specially-crafted `import`s, installing or uninstalling a loader at
+runtime.
+
+See also `ava.config.cjs`
+
+The loader is implemented in `loader.mjs`, and functions to send it commands are
+in `client.ts`.

src/test/test-loader.mjs

@@ -0,0 +1,26 @@
+import { URL } from 'url';
+import type { CreateOptions } from '../..';
+
+// Duplicated in loader.mjs
+const protocol = 'testloader://';
+const clearLoaderCmd = 'clearLoader';
+const setLoaderCmd = 'setLoader';
+
+// Avoid ts compiler transforming import() into require().
+const doImport = new Function('specifier', 'return import(specifier)');
+let cacheBust = 0;
+async function call(url: URL) {
+  url.searchParams.set('cacheBust', `${cacheBust++}`);
+  await doImport(url.toString());
+}
+
+export async function clearLoader() {
+  await call(new URL(`${protocol}${clearLoaderCmd}`));
+}
+
+export async function setLoader(specifier: string, options: CreateOptions | undefined) {
+  const url = new URL(`${protocol}${setLoaderCmd}`);
+  url.searchParams.append('specifier', specifier);
+  url.searchParams.append('options', JSON.stringify(options));
+  await call(url);
+}

src/test/test-loader/README.md

@@ -0,0 +1,69 @@
+import semver from 'semver';
+import { URL } from 'url';
+import { createRequire } from 'module';
+
+export const protocol = 'testloader://';
+
+const newHooksAPI = semver.gte(process.versions.node, '16.12.0');
+
+let hooks = undefined;
+
+const require = createRequire(import.meta.url);
+
+//
+// Commands
+//
+
+export const clearLoaderCmd = 'clearLoader';
+function clearLoader() {
+  hooks = undefined;
+}
+
+export const setLoaderCmd = 'setLoader';
+function setLoader(specifier, options) {
+  const tsNode = require(specifier);
+  const service = tsNode.create(options);
+  hooks = tsNode.createEsmHooks(service);
+}
+
+//
+// Loader hooks
+//
+
+function createHook(name) {
+  return function (a, b, c) {
+    const target = (hooks && hooks[name]) || c;
+    return target(...arguments);
+  };
+}
+
+export const empty = `${protocol}empty`;
+const resolveEmpty = { url: empty, shortCircuit: true };
+
+const _resolve = createHook('resolve');
+export function resolve(specifier, ...rest) {
+  if (specifier.startsWith(protocol)) {
+    const url = new URL(specifier);
+    switch (url.host) {
+      case setLoaderCmd:
+        const specifier = url.searchParams.get('specifier');
+        const options = JSON.parse(url.searchParams.get('options'));
+        setLoader(specifier, options);
+        return resolveEmpty;
+      case clearLoaderCmd:
+        clearLoader();
+        return resolveEmpty;
+    }
+  }
+  return _resolve(specifier, ...rest);
+}
+
+const _loadHook = newHooksAPI ? createHook('load') : null;
+function _load(url, ...rest) {
+  if (url === empty) return { format: 'module', source: '', shortCircuit: true };
+  return _loadHook(url, ...rest);
+}
+export const load = newHooksAPI ? _load : null;
+
+export const getFormat = !newHooksAPI ? createHook('getFormat') : null;
+export const transformSource = !newHooksAPI ? createHook('transformSource') : null;