@jsenv/test 2.1.3 → 3.0.0

package/dist/node_child_process_controlled.mjs

@@ -1,55 +1,54 @@
-import { createException, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { memoryUsage } from "node:process";
+import { createException } from "./js/exception.js";
+import { executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
 import "node:fs";
 import "node:inspector";
 import "node:perf_hooks";
 
+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) => {
@@ -63,16 +62,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);
     }
   };
@@ -83,37 +79,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/dist/node_worker_thread_controlled.mjs

@@ -1,40 +1,31 @@
 import { parentPort } from "node:worker_threads";
-import { createException, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { memoryUsage } from "node:process";
+import { setFlagsFromString } from "node:v8";
+import { runInNewContext } from "node:vm";
+import { createException } from "./js/exception.js";
+import { executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
 import "node:fs";
 import "node:inspector";
 import "node:perf_hooks";
 
-const ACTIONS_AVAILABLE = {
-  "execute-using-dynamic-import": executeUsingDynamicImport,
-};
-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";
+setFlagsFromString("--expose_gc");
+global.gc = runInNewContext("gc");
 
-const sendActionFailed = (error) => {
-  const exception = createException(error);
-  sendToParent(
-    ACTION_RESPONSE_EVENT_NAME,
-    JSON.stringify({
-      status: ACTION_RESPONSE_STATUS_FAILED,
-      value: exception,
-    }),
-  );
-};
+let memoryHeapUsedAtStart;
+if (process.env.MEASURE_MEMORY_AT_START) {
+  global.gc();
+  memoryHeapUsedAtStart = memoryUsage().heapUsed;
+}
 
-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 ACTIONS_AVAILABLE = {
+  "execute-using-dynamic-import": (params) => {
+    return executeUsingDynamicImport(params);
+  },
+  "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 sendToParent = (type, data) => {
@@ -43,16 +34,14 @@ const sendToParent = (type, data) => {
   // It means node process may stay alive longer than expected
   // the time to send the data to the parent.
   parentPort.postMessage({
-    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 worker alive
+    if (message && message.__jsenv__ === "action") {
       callback(message.data);
     }
   };
@@ -63,31 +52,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;
-    }
-
-    if (failed) {
-      sendActionFailed(value);
-    } else {
-      sendActionCompleted(value);
-    }
-    if (actionParams.exitAfterAction) {
-      removeActionRequestListener();
+      sendActionInternalError(id, e);
+    } finally {
+      process.removeListener("uncaughtException", onUncaughtException);
+      if (params.exitAfterAction) {
+        removeActionRequestListener();
+      }
     }
   },
 );

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@jsenv/test",
-  "version": "2.1.3",
+  "version": "3.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/jsenv/core",
     "directory": "packages/related/test"
   },
+  "engines": {
+    "node": ">=20.11.0"
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -33,23 +36,29 @@
     "playwright": "1.x"
   },
   "dependencies": {
-    "@jsenv/abort": "4.2.4",
-    "@jsenv/ast": "6.0.1",
-    "@jsenv/filesystem": "4.6.0",
-    "@jsenv/log": "3.4.3",
-    "@jsenv/plugin-supervisor": "1.4.0",
-    "@jsenv/urls": "2.2.1",
-    "@jsenv/url-meta": "8.2.0",
-    "@jsenv/utils": "2.1.0",
-    "@jsenv/github-check-run": "0.1.6",
-    "v8-to-istanbul": "9.2.0",
+    "@c88/v8-coverage": "0.1.1",
+    "@jsenv/abort": "4.3.0",
+    "@jsenv/ast": "6.0.2",
+    "@jsenv/filesystem": "4.6.3",
+    "@jsenv/github-check-run": "0.1.7",
+    "@jsenv/inspect": "2.0.0",
+    "@jsenv/log": "3.5.1",
+    "@jsenv/plugin-supervisor": "1.4.1",
+    "@jsenv/url-meta": "8.4.0",
+    "@jsenv/urls": "2.2.2",
+    "@jsenv/utils": "2.1.1",
     "istanbul-lib-coverage": "3.2.2",
     "istanbul-lib-instrument": "6.0.1",
     "istanbul-lib-report": "3.0.1",
     "istanbul-reports": "3.1.6",
-    "@c88/v8-coverage": "0.1.1",
+    "he": "1.2.0",
+    "pidtree": "0.6.0",
     "strip-ansi": "7.1.0",
-    "wrap-ansi": "9.0.0",
-    "pidtree": "0.6.0"
+    "v8-to-istanbul": "9.2.0",
+    "wrap-ansi": "9.0.0"
+  },
+  "devDependencies": {
+    "@jsenv/terminal-recorder": "../independent/terminal-recorder/",
+    "errorstacks": "2.4.1"
   }
 }

package/src/coverage/generate_coverage.js

@@ -0,0 +1,186 @@
+import { readFileSync } from "node:fs";
+import { Abort } from "@jsenv/abort";
+
+import { filterV8Coverage } from "./v8_coverage.js";
+import { readNodeV8CoverageDirectory } from "./v8_coverage_node_directory.js";
+import { composeTwoV8Coverages } from "./v8_coverage_composition.js";
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js";
+import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js";
+import { composeV8AndIstanbul } from "./v8_and_istanbul.js";
+import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js";
+import { getMissingFileByFileCoverage } from "./missing_coverage.js";
+
+export const generateCoverage = async (
+  testPlanResult,
+  { signal, logger, rootDirectoryUrl, coverage },
+) => {
+  // collect v8 and istanbul coverage from executions
+  let { v8Coverage, fileByFileIstanbulCoverage } =
+    await getCoverageFromTestPlanResults(testPlanResult.results, {
+      signal,
+      onMissing: ({ file, executionResult, executionName }) => {
+        // several reasons not to have coverage here:
+        // 1. the file we executed did not import an instrumented file.
+        // - a test file without import
+        // - a test file importing only file excluded from coverage
+        // - a coverDescription badly configured so that we don't realize
+        // a file should be covered
+
+        // 2. the file we wanted to executed timedout
+        // - infinite loop
+        // - too extensive operation
+        // - a badly configured or too low allocatedMs for that execution.
+
+        // 3. the file we wanted to execute contains syntax-error
+
+        // in any scenario we are fine because
+        // coverDescription will generate empty coverage for files
+        // that were suppose to be coverage but were not.
+        if (
+          executionResult.status === "completed" &&
+          executionResult.type === "node" &&
+          coverage.methodForNodeJs !== "NODE_V8_COVERAGE"
+        ) {
+          logger.warn(
+            `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
+          );
+        }
+      },
+    });
+
+  if (coverage.methodForNodeJs === "NODE_V8_COVERAGE") {
+    await readNodeV8CoverageDirectory({
+      logger,
+      signal,
+      onV8Coverage: async (nodeV8Coverage) => {
+        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
+          rootDirectoryUrl,
+          coverageInclude: coverage.include,
+        });
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight;
+      },
+    });
+  }
+
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage;
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    });
+
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      rootDirectoryUrl,
+    );
+
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        rootDirectoryUrl,
+      );
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { v8ConflictWarning: coverage.v8ConflictWarning },
+      );
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage;
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
+      rootDirectoryUrl,
+    );
+  }
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {};
+  }
+
+  // now add coverage for file not covered
+  if (coverage.includeMissing) {
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
+      rootDirectoryUrl,
+      coverageInclude: coverage.include,
+      fileByFileCoverage,
+    });
+    Object.assign(
+      fileByFileCoverage,
+      normalizeFileByFileCoveragePaths(
+        missingFileByFileCoverage,
+        rootDirectoryUrl,
+      ),
+    );
+  }
+
+  return fileByFileCoverage;
+};
+
+const getCoverageFromTestPlanResults = async (
+  executionResults,
+  { signal, onMissing },
+) => {
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+
+  try {
+    let v8Coverage;
+    let fileByFileIstanbulCoverage;
+
+    // collect v8 and istanbul coverage from executions
+    for (const file of Object.keys(executionResults)) {
+      const executionResultForFile = executionResults[file];
+      for (const executionName of Object.keys(executionResultForFile)) {
+        operation.throwIfAborted();
+
+        const executionResultForFileOnRuntime =
+          executionResultForFile[executionName];
+        const { coverageFileUrl } = executionResultForFileOnRuntime;
+        let executionCoverage;
+        try {
+          executionCoverage = JSON.parse(
+            String(readFileSync(new URL(coverageFileUrl))),
+          );
+        } catch (e) {
+          if (e.code === "ENOENT" || e.name === "SyntaxError") {
+            onMissing({
+              executionName,
+              file,
+              executionResult: executionResultForFileOnRuntime,
+            });
+            continue;
+          }
+          throw e;
+        }
+
+        if (isV8Coverage(executionCoverage)) {
+          v8Coverage = v8Coverage
+            ? composeTwoV8Coverages(v8Coverage, executionCoverage)
+            : executionCoverage;
+        } else {
+          fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
+            ? composeTwoFileByFileIstanbulCoverages(
+                fileByFileIstanbulCoverage,
+                executionCoverage,
+              )
+            : executionCoverage;
+        }
+      }
+    }
+
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    };
+  } finally {
+    await operation.end();
+  }
+};
+
+const isV8Coverage = (coverage) => Boolean(coverage.result);

package/src/coverage/list_files_not_covered.js

@@ -3,12 +3,12 @@ import { collectFiles } from "@jsenv/filesystem";
 export const listRelativeFileUrlToCover = async ({
   signal,
   rootDirectoryUrl,
-  coverageConfig,
+  coverageInclude,
 }) => {
   const matchingFileResultArray = await collectFiles({
     signal,
     directoryUrl: rootDirectoryUrl,
-    associations: { cover: coverageConfig },
+    associations: { cover: coverageInclude },
     predicate: ({ cover }) => cover,
   });
   return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl);

package/src/coverage/missing_coverage.js

@@ -6,13 +6,13 @@ import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.js";
 export const getMissingFileByFileCoverage = async ({
   signal,
   rootDirectoryUrl,
-  coverageConfig,
+  coverageInclude,
   fileByFileCoverage,
 }) => {
   const relativeUrlsToCover = await listRelativeFileUrlToCover({
     signal,
     rootDirectoryUrl,
-    coverageConfig,
+    coverageInclude,
   });
   const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
     Object.keys(fileByFileCoverage).every((key) => {