Move setup code into fixture; avoid global; add JSON.stringify, __proto__

Author: GeoffreyBooth

test/es-module/test-esm-loader-mock.mjs

@@ -1,73 +1,6 @@
-// Flags: --no-warnings
-import '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
+// Flags: --no-warnings --import ./test/fixtures/es-module-loaders/mock.mjs
 import assert from 'node:assert/strict';
-import { register } from 'node:module';
-import { MessageChannel } from 'node:worker_threads';
-
-const { port1, port2 } = new MessageChannel();
-
-register(fixtures.fileURL('es-module-loaders/mock-loader.mjs'), {
-  parentURL: import.meta.url,
-  data: { port: port2 },
-  transferList: [port2],
-});
-
-/**
- * This is the Map that saves *all* the mocked URL -> replacement Module
- * mappings
- * @type {Map<string, {namespace, listeners}>}
- */
-globalThis.mockedModules = new Map();
-let mockVersion = 0;
-
-/**
- * @param {string} resolved an absolute URL HREF string
- * @param {object} replacementProperties an object to pick properties from
- *                                       to act as a module namespace
- * @returns {object} a mutator object that can update the module namespace
- *                   since we can't do something like old Object.observe
- */
-function mock(resolved, replacementProperties) {
-  const exportNames = Object.keys(replacementProperties);
-  const namespace = { __proto__: null };
-  /**
-   * @type {Array<(name: string)=>void>} functions to call whenever an
-   *                                     export name is updated
-   */
-  const listeners = [];
-  for (const name of exportNames) {
-    let currentValueForPropertyName = replacementProperties[name];
-    Object.defineProperty(namespace, name, {
-      enumerable: true,
-      get() {
-        return currentValueForPropertyName;
-      },
-      set(v) {
-        currentValueForPropertyName = v;
-        for (const fn of listeners) {
-          try {
-            fn(name);
-          } catch {
-            /* noop */
-          }
-        }
-      }
-    });
-  }
-  globalThis.mockedModules.set(encodeURIComponent(resolved), {
-    namespace,
-    listeners
-  });
-  mockVersion++;
-  // Inform the loader that the `resolved` URL should now use the specific
-  // `mockVersion` and has export names of `exportNames`
-  //
-  // This allows the loader to generate a fake module for that version
-  // and names the next time it resolves a specifier to equal `resolved`
-  port1.postMessage({ mockVersion, resolved, exports: exportNames });
-  return namespace;
-}
+import { mock } from '../fixtures/es-module-loaders/mock.mjs';
 
 mock('node:events', {
   EventEmitter: 'This is mocked!'
@@ -107,5 +40,3 @@ assert.deepStrictEqual(mockedV2, Object.defineProperty({
   enumerable: false,
   value: 'Module'
 }));
-
-delete globalThis.mockedModules;

test/fixtures/es-module-loaders/mock-loader.mjs

@@ -75,6 +75,7 @@ export async function load(url, context, defaultLoad) {
   return defaultLoad(url, context);
 }
 
+const mainImportURL = new URL('./mock.mjs', import.meta.url);
 /**
  * Generate the source code for a mocked module.
  * @param {string} encodedTargetURL the module being mocked
@@ -85,12 +86,13 @@ function generateModule(encodedTargetURL) {
     decodeURIComponent(encodedTargetURL)
   );
   let body = [
+    `import { mockedModules } from '${mainImportURL}';`,
     'export {};',
     'let mapping = {__proto__: null};'
   ];
   for (const [i, name] of Object.entries(exports)) {
     let key = JSON.stringify(name);
-    body.push(`import.meta.mock = globalThis.mockedModules.get('${encodedTargetURL}');`);
+    body.push(`import.meta.mock = mockedModules.get(${JSON.stringify(encodedTargetURL)});`);
     body.push(`var _${i} = import.meta.mock.namespace[${key}];`);
     body.push(`Object.defineProperty(mapping, ${key}, { enumerable: true, set(v) {_${i} = v;}, get() {return _${i};} });`);
     body.push(`export {_${i} as ${name}};`);

test/fixtures/es-module-loaders/mock.mjs

@@ -0,0 +1,68 @@
+import * as fixtures from '../../common/fixtures.mjs';
+import { register } from 'node:module';
+import { MessageChannel } from 'node:worker_threads';
+
+
+const { port1, port2 } = new MessageChannel();
+
+register(fixtures.fileURL('es-module-loaders/mock-loader.mjs'), {
+  data: { port: port2 },
+  transferList: [port2],
+});
+
+/**
+ * This is the Map that saves *all* the mocked URL -> replacement Module
+ * mappings
+ * @type {Map<string, {namespace, listeners}>}
+ */
+export const mockedModules = new Map();
+let mockVersion = 0;
+
+/**
+ * @param {string} resolved an absolute URL HREF string
+ * @param {object} replacementProperties an object to pick properties from
+ *                                       to act as a module namespace
+ * @returns {object} a mutator object that can update the module namespace
+ *                   since we can't do something like old Object.observe
+ */
+export function mock(resolved, replacementProperties) {
+  const exportNames = Object.keys(replacementProperties);
+  const namespace = { __proto__: null };
+  /**
+   * @type {Array<(name: string)=>void>} functions to call whenever an
+   *                                     export name is updated
+   */
+  const listeners = [];
+  for (const name of exportNames) {
+    let currentValueForPropertyName = replacementProperties[name];
+    Object.defineProperty(namespace, name, {
+      __proto__: null,
+      enumerable: true,
+      get() {
+        return currentValueForPropertyName;
+      },
+      set(v) {
+        currentValueForPropertyName = v;
+        for (const fn of listeners) {
+          try {
+            fn(name);
+          } catch {
+            /* noop */
+          }
+        }
+      }
+    });
+  }
+  mockedModules.set(encodeURIComponent(resolved), {
+    namespace,
+    listeners
+  });
+  mockVersion++;
+  // Inform the loader that the `resolved` URL should now use the specific
+  // `mockVersion` and has export names of `exportNames`
+  //
+  // This allows the loader to generate a fake module for that version
+  // and names the next time it resolves a specifier to equal `resolved`
+  port1.postMessage({ mockVersion, resolved, exports: exportNames });
+  return namespace;
+}