@jsenv/test 2.1.3 → 3.0.1

package/src/runtime_node/node_child_process_controlled.mjs

@@ -1,53 +1,52 @@
+import { memoryUsage } from "node:process";
+
 import { createException } from "../execution/exception.js";
 import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 
+let memoryHeapUsedAtStart;
+if (process.env.MEASURE_MEMORY_AT_START) {
+  global.gc();
+  memoryHeapUsedAtStart = memoryUsage().heapUsed;
+}
+
 const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import": executeUsingDynamicImport,
+  "execute-using-dynamic-import": (params) => {
+    return executeUsingDynamicImport(params);
+  },
   "execute-using-require": async ({ fileUrl }) => {
-    const { createRequire } = await import("node:module");
-    const { fileURLToPath } = await import("node:url");
-    const filePath = fileURLToPath(fileUrl);
-    const require = createRequire(fileUrl);
-    // eslint-disable-next-line import/no-dynamic-require
-    const namespace = require(filePath);
-    const namespaceResolved = {};
-    await Promise.all(
-      Object.keys(namespace).map(async (key) => {
-        const value = await namespace[key];
-        namespaceResolved[key] = value;
-      }),
-    );
-    return namespaceResolved;
+    const result = {
+      timings: {
+        start: null,
+        end: null,
+      },
+      namespace: null,
+    };
+    try {
+      const { createRequire } = await import("node:module");
+      const { fileURLToPath } = await import("node:url");
+      const filePath = fileURLToPath(fileUrl);
+      const require = createRequire(fileUrl);
+      result.timings.start = Date.now();
+      // eslint-disable-next-line import/no-dynamic-require
+      const namespace = require(filePath);
+      const namespaceResolved = {};
+      await Promise.all(
+        Object.keys(namespace).map(async (key) => {
+          const value = await namespace[key];
+          namespaceResolved[key] = value;
+        }),
+      );
+      result.namespace = namespaceResolved;
+    } finally {
+      result.timings.end = Date.now();
+      return result;
+    }
+  },
+  "measure-memory-usage": () => {
+    // we compare usage - usageAtstart to prevent
+    // node or os specificities to have too much influences on the measures
+    return memoryUsage().heapUsed - memoryHeapUsedAtStart;
   },
-};
-const ACTION_REQUEST_EVENT_NAME = "action";
-const ACTION_RESPONSE_EVENT_NAME = "action-result";
-const ACTION_RESPONSE_STATUS_FAILED = "action-failed";
-const ACTION_RESPONSE_STATUS_COMPLETED = "action-completed";
-
-const sendActionFailed = (error) => {
-  const exception = createException(error);
-  sendToParent(
-    ACTION_RESPONSE_EVENT_NAME,
-    JSON.stringify({
-      status: ACTION_RESPONSE_STATUS_FAILED,
-      value: exception,
-    }),
-  );
-};
-
-const sendActionCompleted = (value) => {
-  sendToParent(
-    ACTION_RESPONSE_EVENT_NAME,
-    // here we use JSON.stringify because we should not
-    // have non enumerable value (unlike there is on Error objects)
-    // otherwise uneval is quite slow to turn a giant object
-    // into a string (and value can be giant when using coverage)
-    JSON.stringify({
-      status: ACTION_RESPONSE_STATUS_COMPLETED,
-      value,
-    }),
-  );
 };
 
 const sendToParent = (type, data) => {
@@ -61,16 +60,13 @@ const sendToParent = (type, data) => {
   // It means node process may stay alive longer than expected
   // the time to send the data to the parent.
   process.send({
-    jsenv: true,
-    type,
+    __jsenv__: type,
     data,
   });
 };
-
-const onceParentMessage = (type, callback) => {
+const onActionRequestedByParent = (callback) => {
   const listener = (message) => {
-    if (message && message.jsenv && message.type === type) {
-      removeListener(); // commenting this line keep this process alive
+    if (message && message.__jsenv__ === "action") {
       callback(message.data);
     }
   };
@@ -81,37 +77,60 @@ const onceParentMessage = (type, callback) => {
   return removeListener;
 };
 
-const removeActionRequestListener = onceParentMessage(
-  ACTION_REQUEST_EVENT_NAME,
-  async ({ actionType, actionParams }) => {
-    const action = ACTIONS_AVAILABLE[actionType];
+const removeActionRequestListener = onActionRequestedByParent(
+  async ({ id, type, params = {} }) => {
+    const sendActionInternalError = (id, error) => {
+      const exception = createException(error);
+      sendToParent(
+        "action-result",
+        JSON.stringify({
+          id,
+          status: "error",
+          value: exception,
+        }),
+      );
+    };
+    const sendActionCompleted = (id, value) => {
+      sendToParent(
+        "action-result",
+        // here we use JSON.stringify because we should not
+        // have non enumerable value (unlike there is on Error objects)
+        // otherwise uneval is quite slow to turn a giant object
+        // into a string (and value can be giant when using coverage)
+        JSON.stringify({
+          id,
+          status: "completed",
+          value,
+        }),
+      );
+    };
+
+    const action = ACTIONS_AVAILABLE[type];
     if (!action) {
-      sendActionFailed(new Error(`unknown action ${actionType}`));
+      sendActionInternalError(id, new Error(`unknown action ${type}`));
       return;
     }
 
-    let value;
-    let failed = false;
+    let gotInternalError = false;
+    const onUncaughtException = (err) => {
+      gotInternalError = true;
+      sendActionInternalError(id, err);
+      process.exit(1);
+    };
+    process.on("uncaughtException", onUncaughtException);
+
     try {
-      value = await action(actionParams);
+      const value = await action(params);
+      if (!gotInternalError) {
+        sendActionCompleted(id, value);
+      }
     } catch (e) {
-      failed = true;
-      value = e;
-    }
-
-    // setTimeout(() => {}, 100)
-
-    if (failed) {
-      sendActionFailed(value);
-    } else {
-      sendActionCompleted(value);
-    }
-
-    // removeActionRequestListener()
-    if (actionParams.exitAfterAction) {
-      removeActionRequestListener();
-      // for some reason this fixes v8 coverage directory sometimes empty on Ubuntu
-      // process.exit()
+      sendActionInternalError(id, e);
+    } finally {
+      process.removeListener("uncaughtException", onUncaughtException);
+      if (params.exitAfterAction) {
+        removeActionRequestListener();
+      }
     }
   },
 );

package/src/runtime_node/node_worker_thread.js

@@ -3,11 +3,7 @@
 // https://github.com/avajs/ava/blob/576f534b345259055c95fa0c2b33bef10847a2af/lib/worker/base.js
 import { Worker } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
-import {
-  Abort,
-  createCallbackListNotifiedOnce,
-  raceCallbacks,
-} from "@jsenv/abort";
+import { Abort, raceCallbacks } from "@jsenv/abort";
 import { memoize } from "@jsenv/utils/src/memoize/memoize.js";
 
 import { createChildExecOptions } from "./child_exec_options.js";
@@ -51,17 +47,24 @@ export const nodeWorkerThread = ({
       keepRunning,
       stopSignal,
       onConsole,
+      onRuntimeStarted,
+      onRuntimeStopped,
 
+      measureMemoryUsage,
+      onMeasureMemoryAvailable,
       collectConsole = false,
       collectPerformance,
       coverageEnabled = false,
-      coverageConfig,
+      coverageInclude,
       coverageMethodForNodeJs,
       coverageFileUrl,
     }) => {
       if (coverageMethodForNodeJs !== "NODE_V8_COVERAGE") {
         env.NODE_V8_COVERAGE = "";
       }
+      if (onMeasureMemoryAvailable) {
+        env.MEASURE_MEMORY_AT_START = "1";
+      }
       if (importMap) {
         env.IMPORT_MAP = JSON.stringify(importMap);
         env.IMPORT_MAP_BASE_URL = rootDirectoryUrl;
@@ -86,10 +89,16 @@ export const nodeWorkerThread = ({
         ...env,
       };
 
-      const cleanupCallbackList = createCallbackListNotifiedOnce();
+      const cleanupCallbackSet = new Set();
       const cleanup = async (reason) => {
-        await cleanupCallbackList.notify({ reason });
+        const promises = [];
+        for (const cleanupCallback of cleanupCallbackSet) {
+          promises.push(cleanupCallback({ reason }));
+        }
+        cleanupCallbackSet.clear();
+        await Promise.all(promises);
       };
+
       const actionOperation = Abort.startOperation();
       actionOperation.addAbortSignal(signal);
       // https://nodejs.org/api/worker_threads.html#new-workerfilename-options
@@ -111,13 +120,26 @@ export const nodeWorkerThread = ({
         },
       );
       const workerThreadReadyPromise = new Promise((resolve) => {
-        onceWorkerThreadMessage(workerThread, "ready", resolve);
+        const removeReadyListener = onWorkerThreadMessage(
+          workerThread,
+          "ready",
+          () => {
+            removeReadyListener();
+            onRuntimeStarted();
+            resolve();
+          },
+        );
       });
+      cleanupCallbackSet.add(
+        onceWorkerThreadEvent(workerThread, "exit", () => {
+          onRuntimeStopped();
+        }),
+      );
 
       const stop = memoize(async () => {
         // read all stdout before terminating
         // (no need for stderr because it's sync)
-        if (collectConsole) {
+        if (collectConsole || onConsole) {
           while (workerThread.stdout.read() !== null) {}
           await new Promise((resolve) => {
             setTimeout(resolve, 50);
@@ -126,134 +148,175 @@ export const nodeWorkerThread = ({
         await workerThread.terminate();
       });
 
-      const winnerPromise = new Promise((resolve) => {
-        raceCallbacks(
-          {
-            aborted: (cb) => {
-              return actionOperation.addAbortCallback(cb);
-            },
-            error: (cb) => {
-              return onceWorkerThreadEvent(workerThread, "error", cb);
-            },
-            exit: (cb) => {
-              return onceWorkerThreadEvent(
-                workerThread,
-                "exit",
-                (code, signal) => {
-                  cb({ code, signal });
-                },
-              );
-            },
-            response: (cb) => {
-              return onceWorkerThreadMessage(workerThread, "action-result", cb);
-            },
-          },
-          resolve,
-        );
-      });
-
       const result = {
         status: "executing",
         errors: [],
         namespace: null,
+        timings: {},
+        memoryUsage: null,
+        performance: null,
       };
 
-      const writeResult = async () => {
+      try {
+        let executionInternalErrorCallback;
+        let executionCompletedCallback;
+        const winnerPromise = new Promise((resolve) => {
+          raceCallbacks(
+            {
+              aborted: (cb) => {
+                return actionOperation.addAbortCallback(cb);
+              },
+              error: (cb) => {
+                return onceWorkerThreadEvent(workerThread, "error", cb);
+              },
+              exit: (cb) => {
+                return onceWorkerThreadEvent(
+                  workerThread,
+                  "exit",
+                  (code, signal) => {
+                    cb({ code, signal });
+                  },
+                );
+              },
+              execution_internal_error: (cb) => {
+                executionInternalErrorCallback = cb;
+              },
+              execution_completed: (cb) => {
+                executionCompletedCallback = cb;
+              },
+            },
+            resolve,
+          );
+        });
+        const raceHandlers = {
+          aborted: () => {
+            result.status = "aborted";
+          },
+          error: (error) => {
+            removeOutputListener();
+            result.status = "failed";
+            result.errors.push(error);
+          },
+          exit: ({ code }) => {
+            onRuntimeStopped();
+            if (code === 12) {
+              result.status = "failed";
+              result.errors.push(
+                new Error(
+                  `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
+                ),
+              );
+              return;
+            }
+            if (code === null || code === 0) {
+              result.status = "completed";
+              result.namespace = {};
+              return;
+            }
+            if (
+              code === EXIT_CODES.SIGINT ||
+              code === EXIT_CODES.SIGTERM ||
+              code === EXIT_CODES.SIGABORT
+            ) {
+              result.status = "failed";
+              result.errors.push(
+                new Error(`node worker thread exited during execution`),
+              );
+              return;
+            }
+            // process.exit(1) in child process or process.exitCode = 1 + process.exit()
+            // means there was an error even if we don't know exactly what.
+            result.status = "failed";
+            result.errors.push(
+              new Error(
+                `node worker thread exited with code ${code} during execution`,
+              ),
+            );
+          },
+          execution_internal_error: (error) => {
+            result.status = "failed";
+            result.errors.push(error);
+          },
+          execution_completed: ({
+            status,
+            errors,
+            namespace,
+            timings,
+            memoryUsage,
+            performance,
+            coverage,
+          }) => {
+            result.status = status;
+            result.errors = errors;
+            result.namespace = namespace;
+            result.timings = timings;
+            result.memoryUsage = memoryUsage;
+            result.performance = performance;
+            result.coverage = coverage;
+          },
+        };
+
         actionOperation.throwIfAborted();
         await workerThreadReadyPromise;
         actionOperation.throwIfAborted();
-        await sendToWorkerThread(workerThread, {
-          type: "action",
-          data: {
-            actionType: "execute-using-dynamic-import",
-            actionParams: {
+        if (onMeasureMemoryAvailable) {
+          onMeasureMemoryAvailable(async () => {
+            let _resolve;
+            const memoryUsagePromise = new Promise((resolve) => {
+              _resolve = resolve;
+            });
+            await requestActionOnWorkerThread(
+              workerThread,
+              {
+                type: "measure-memory-usage",
+              },
+              ({ value }) => {
+                _resolve(value);
+              },
+            );
+            return memoryUsagePromise;
+          });
+        }
+        await requestActionOnWorkerThread(
+          workerThread,
+          {
+            type: "execute-using-dynamic-import",
+            params: {
               rootDirectoryUrl,
               fileUrl: new URL(fileRelativeUrl, rootDirectoryUrl).href,
+              measureMemoryUsage,
               collectPerformance,
               coverageEnabled,
-              coverageConfig,
+              coverageInclude,
               coverageMethodForNodeJs,
               coverageFileUrl,
               exitAfterAction: true,
             },
           },
-        });
+          ({ status, value }) => {
+            if (status === "error") {
+              executionInternalErrorCallback(value);
+            } else {
+              executionCompletedCallback(value);
+            }
+          },
+        );
         const winner = await winnerPromise;
-        if (winner.name === "aborted") {
-          result.status = "aborted";
-          return;
-        }
-        if (winner.name === "error") {
-          const error = winner.data;
-          removeOutputListener();
-          result.status = "failed";
-          result.errors.push(error);
-          return;
-        }
-        if (winner.name === "exit") {
-          const { code } = winner.data;
-          await cleanup("process exit");
-          if (code === 12) {
-            result.status = "failed";
-            result.errors.push(
-              new Error(
-                `node process exited with 12 (the forked child process wanted to use a non-available port for debug)`,
-              ),
-            );
-            return;
-          }
-          if (code === null || code === 0) {
-            result.status = "completed";
-            result.namespace = {};
-            return;
-          }
-          if (
-            code === EXIT_CODES.SIGINT ||
-            code === EXIT_CODES.SIGTERM ||
-            code === EXIT_CODES.SIGABORT
-          ) {
-            result.status = "failed";
-            result.errors.push(
-              new Error(`node worker thread exited during execution`),
-            );
-            return;
-          }
-          // process.exit(1) in child process or process.exitCode = 1 + process.exit()
-          // means there was an error even if we don't know exactly what.
-          result.status = "failed";
-          result.errors.push(
-            new Error(
-              `node worker thread exited with code ${code} during execution`,
-            ),
-          );
-        }
-        const { status, value } = winner.data;
-        if (status === "action-failed") {
-          result.status = "failed";
-          result.errors.push(value);
-          return;
-        }
-        const { namespace, performance, coverage } = value;
-        result.status = "completed";
-        result.namespace = namespace;
-        result.performance = performance;
-        result.coverage = coverage;
-      };
-
-      try {
-        await writeResult();
+        raceHandlers[winner.name](winner.data);
       } catch (e) {
         result.status = "failed";
         result.errors.push(e);
+      } finally {
+        if (keepRunning) {
+          stopSignal.notify = stop;
+        } else {
+          await stop();
+          onRuntimeStopped();
+        }
+        await actionOperation.end();
+        await cleanup();
+        return result;
       }
-
-      if (keepRunning) {
-        stopSignal.notify = stop;
-      } else {
-        await stop();
-      }
-      await actionOperation.end();
-      return result;
     },
   };
 };
@@ -276,14 +339,37 @@ const installWorkerThreadOutputListener = (workerThread, callback) => {
   };
 };
 
-const sendToWorkerThread = (worker, { type, data }) => {
-  worker.postMessage({ jsenv: true, type, data });
+let previousId = 0;
+const requestActionOnWorkerThread = (
+  workerThread,
+  { type, params },
+  onResponse,
+) => {
+  const actionId = previousId + 1;
+  previousId = actionId;
+  const removeResultListener = onWorkerThreadMessage(
+    workerThread,
+    "action-result",
+    ({ id, ...payload }) => {
+      if (id === actionId) {
+        removeResultListener();
+        onResponse(payload);
+      }
+    },
+  );
+  workerThread.postMessage({
+    __jsenv__: "action",
+    data: {
+      id: actionId,
+      type,
+      params,
+    },
+  });
 };
 
-const onceWorkerThreadMessage = (workerThread, type, callback) => {
+const onWorkerThreadMessage = (workerThread, type, callback) => {
   const onmessage = (message) => {
-    if (message && message.jsenv && message.type === type) {
-      workerThread.removeListener("message", onmessage);
+    if (message && message.__jsenv__ === type) {
       callback(message.data ? JSON.parse(message.data) : undefined);
     }
   };