@jsenv/test 2.1.3 → 3.0.0

package/src/runtime_node/node_worker_thread_controlled.mjs

@@ -1,39 +1,29 @@
 import { parentPort } from "node:worker_threads";
+import { memoryUsage } from "node:process";
+import { setFlagsFromString } from "node:v8";
+import { runInNewContext } from "node:vm";
 
 import { createException } from "../execution/exception.js";
 import { executeUsingDynamicImport } from "./execute_using_dynamic_import.js";
 
-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) => {
@@ -42,16 +32,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);
     }
   };
@@ -62,31 +50,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/src/coverage/coverage_reporter_html_directory.js

@@ -1,32 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
-
-import { importWithRequire } from "../helpers/import_with_require.js";
-import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js";
-
-export const generateCoverageHtmlDirectory = async (
-  coverage,
-  {
-    rootDirectoryUrl,
-    coverageHtmlDirectoryRelativeUrl,
-    coverageReportSkipEmpty,
-    coverageReportSkipFull,
-  },
-) => {
-  const libReport = importWithRequire("istanbul-lib-report");
-  const reports = importWithRequire("istanbul-reports");
-
-  const context = libReport.createContext({
-    dir: fileURLToPath(rootDirectoryUrl),
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
-    sourceFinder: (path) =>
-      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
-  });
-
-  const report = reports.create("html", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
-    subdir: coverageHtmlDirectoryRelativeUrl,
-  });
-  report.execute(context);
-};

package/src/coverage/coverage_reporter_json_file.js

@@ -1,17 +0,0 @@
-import { writeFile } from "@jsenv/filesystem";
-import { urlToFileSystemPath } from "@jsenv/urls";
-import { byteAsFileSize } from "@jsenv/log";
-
-export const generateCoverageJsonFile = async ({
-  coverage,
-  coverageJsonFileUrl,
-  logger,
-}) => {
-  const coverageAsText = JSON.stringify(coverage, null, "  ");
-  logger.info(
-    `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
-      Buffer.byteLength(coverageAsText),
-    )})`,
-  );
-  await writeFile(coverageJsonFileUrl, coverageAsText);
-};

package/src/coverage/report_to_coverage.js

@@ -1,198 +0,0 @@
-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 reportToCoverage = async (
-  report,
-  {
-    signal,
-    logger,
-    rootDirectoryUrl,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageMethodForNodeJs,
-    coverageV8ConflictWarning,
-  },
-) => {
-  // collect v8 and istanbul coverage from executions
-  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
-    signal,
-    report,
-    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" &&
-        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
-      ) {
-        logger.warn(
-          `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
-        );
-      }
-    },
-  });
-
-  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
-    await readNodeV8CoverageDirectory({
-      logger,
-      signal,
-      onV8Coverage: async (nodeV8Coverage) => {
-        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
-          rootDirectoryUrl,
-          coverageConfig,
-        });
-        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,
-        { coverageV8ConflictWarning },
-      );
-    } 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 (coverageIncludeMissing) {
-    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
-      signal,
-      rootDirectoryUrl,
-      coverageConfig,
-      fileByFileCoverage,
-    });
-    Object.assign(
-      fileByFileCoverage,
-      normalizeFileByFileCoveragePaths(
-        missingFileByFileCoverage,
-        rootDirectoryUrl,
-      ),
-    );
-  }
-
-  return fileByFileCoverage;
-};
-
-const getCoverageFromReport = async ({ signal, report, onMissing }) => {
-  const operation = Abort.startOperation();
-  operation.addAbortSignal(signal);
-
-  try {
-    let v8Coverage;
-    let fileByFileIstanbulCoverage;
-
-    // collect v8 and istanbul coverage from executions
-    await Object.keys(report).reduce(async (previous, file) => {
-      operation.throwIfAborted();
-      await previous;
-
-      const executionResultForFile = report[file];
-      await Object.keys(executionResultForFile).reduce(
-        async (previous, executionName) => {
-          operation.throwIfAborted();
-          await previous;
-
-          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,
-              });
-              return;
-            }
-            throw e;
-          }
-
-          if (isV8Coverage(executionCoverage)) {
-            v8Coverage = v8Coverage
-              ? composeTwoV8Coverages(v8Coverage, executionCoverage)
-              : executionCoverage;
-          } else {
-            fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
-              ? composeTwoFileByFileIstanbulCoverages(
-                  fileByFileIstanbulCoverage,
-                  executionCoverage,
-                )
-              : executionCoverage;
-          }
-        },
-        Promise.resolve(),
-      );
-    }, Promise.resolve());
-
-    return {
-      v8Coverage,
-      fileByFileIstanbulCoverage,
-    };
-  } finally {
-    await operation.end();
-  }
-};
-
-const isV8Coverage = (coverage) => Boolean(coverage.result);

package/src/execution/execution_colors.js

@@ -1,10 +0,0 @@
-import { ANSI } from "@jsenv/log";
-
-export const EXECUTION_COLORS = {
-  executing: ANSI.BLUE,
-  aborted: ANSI.MAGENTA,
-  timedout: ANSI.MAGENTA,
-  failed: ANSI.RED,
-  completed: ANSI.GREEN,
-  cancelled: ANSI.GREY,
-};

package/src/execution/execution_steps.js

@@ -1,65 +0,0 @@
-import { Abort } from "@jsenv/abort";
-import { collectFiles } from "@jsenv/filesystem";
-import { createDetailedMessage } from "@jsenv/log";
-
-export const executionStepsFromTestPlan = async ({
-  signal,
-  rootDirectoryUrl,
-  testPlan,
-}) => {
-  try {
-    const fileResultArray = await collectFiles({
-      signal,
-      directoryUrl: rootDirectoryUrl,
-      associations: { testPlan },
-      predicate: ({ testPlan }) => testPlan,
-    });
-    const executionSteps = [];
-    fileResultArray.forEach(({ relativeUrl, meta }) => {
-      const fileExecutionSteps = generateFileExecutionSteps({
-        fileRelativeUrl: relativeUrl,
-        filePlan: meta.testPlan,
-      });
-      executionSteps.push(...fileExecutionSteps);
-    });
-    return executionSteps;
-  } catch (e) {
-    if (Abort.isAbortError(e)) {
-      return {
-        aborted: true,
-        planSummary: {},
-        planReport: {},
-        planCoverage: null,
-      };
-    }
-    throw e;
-  }
-};
-
-export const generateFileExecutionSteps = ({ fileRelativeUrl, filePlan }) => {
-  const fileExecutionSteps = [];
-  Object.keys(filePlan).forEach((executionName) => {
-    const stepConfig = filePlan[executionName];
-    if (stepConfig === null || stepConfig === undefined) {
-      return;
-    }
-    if (typeof stepConfig !== "object") {
-      throw new TypeError(
-        createDetailedMessage(
-          `found unexpected value in plan, they must be object`,
-          {
-            ["file relative path"]: fileRelativeUrl,
-            ["execution name"]: executionName,
-            ["value"]: stepConfig,
-          },
-        ),
-      );
-    }
-    fileExecutionSteps.push({
-      executionName,
-      fileRelativeUrl,
-      ...stepConfig,
-    });
-  });
-  return fileExecutionSteps;
-};