@jsenv/test 2.1.3 → 3.0.1

package/src/coverage/report_coverage_as_html.js

@@ -0,0 +1,45 @@
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { urlToRelativeUrl } from "@jsenv/urls";
+import { ensureEmptyDirectorySync } from "@jsenv/filesystem";
+
+import { importWithRequire } from "../helpers/import_with_require.js";
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js";
+
+export const reportCoverageAsHtml = (
+  testPlanResult,
+  directoryUrl,
+  { skipEmpty, skipFull } = {},
+) => {
+  if (testPlanResult.aborted) {
+    return;
+  }
+  const testPlanCoverage = testPlanResult.coverage;
+  if (!testPlanCoverage) {
+    // TODO
+  }
+
+  const { rootDirectoryUrl } = testPlanResult;
+  ensureEmptyDirectorySync(directoryUrl);
+  const coverageHtmlDirectoryRelativeUrl = urlToRelativeUrl(
+    directoryUrl,
+    rootDirectoryUrl,
+  );
+
+  const libReport = importWithRequire("istanbul-lib-report");
+  const reports = importWithRequire("istanbul-reports");
+  const context = libReport.createContext({
+    dir: fileURLToPath(rootDirectoryUrl),
+    coverageMap: istanbulCoverageMapFromCoverage(testPlanCoverage),
+    sourceFinder: (path) =>
+      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
+  });
+  const report = reports.create("html", {
+    skipEmpty,
+    skipFull,
+    subdir: coverageHtmlDirectoryRelativeUrl,
+  });
+  report.execute(context);
+  // const htmlCoverageDirectoryIndexFileUrl = `${directoryUrl}index.html`;
+  // console.log(`-> ${urlToFileSystemPath(htmlCoverageDirectoryIndexFileUrl)}`);
+};

package/src/coverage/report_coverage_as_json.js

@@ -0,0 +1,20 @@
+import { urlToFileSystemPath } from "@jsenv/urls";
+import { writeFileSync } from "@jsenv/filesystem";
+import { inspectFileSize } from "@jsenv/inspect";
+
+export const reportCoverageAsJson = (testPlanResult, fileUrl) => {
+  if (testPlanResult.aborted) {
+    return;
+  }
+  const testPlanCoverage = testPlanResult.coverage;
+  if (!testPlanCoverage) {
+    // TODO
+  }
+  const coverageAsText = JSON.stringify(testPlanCoverage, null, "  ");
+  writeFileSync(fileUrl, coverageAsText);
+  console.log(
+    `-> ${urlToFileSystemPath(fileUrl)} (${inspectFileSize(
+      Buffer.byteLength(coverageAsText),
+    )})`,
+  );
+};

package/src/coverage/{coverage_reporter_text_log.js → report_coverage_in_console.js}

@@ -1,19 +1,25 @@
 import { importWithRequire } from "../helpers/import_with_require.js";
 import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js";
 
-export const generateCoverageTextLog = (
-  coverage,
-  { coverageReportSkipEmpty, coverageReportSkipFull },
+export const reportCoverageInConsole = (
+  testPlanResult,
+  { skipEmpty, skipFull } = {},
 ) => {
+  if (testPlanResult.aborted) {
+    return;
+  }
+  const testPlanCoverage = testPlanResult.coverage;
+  if (!testPlanCoverage) {
+    // TODO
+  }
   const libReport = importWithRequire("istanbul-lib-report");
   const reports = importWithRequire("istanbul-reports");
-
   const context = libReport.createContext({
-    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+    coverageMap: istanbulCoverageMapFromCoverage(testPlanCoverage),
   });
   const report = reports.create("text", {
-    skipEmpty: coverageReportSkipEmpty,
-    skipFull: coverageReportSkipFull,
+    skipEmpty,
+    skipFull,
   });
   report.execute(context);
 };

package/src/coverage/v8_and_istanbul.js

@@ -3,7 +3,7 @@ import { createDetailedMessage } from "@jsenv/log";
 export const composeV8AndIstanbul = (
   v8FileByFileCoverage,
   istanbulFileByFileCoverage,
-  { coverageV8ConflictWarning },
+  { v8ConflictWarning },
 ) => {
   const fileByFileCoverage = {};
   const v8Files = Object.keys(v8FileByFileCoverage);
@@ -15,15 +15,15 @@ export const composeV8AndIstanbul = (
   istanbulFiles.forEach((key) => {
     const v8Coverage = v8FileByFileCoverage[key];
     if (v8Coverage) {
-      if (coverageV8ConflictWarning) {
+      if (v8ConflictWarning) {
         console.warn(
           createDetailedMessage(
             `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
             {
               "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
               "suggestion":
-                "disable this warning with coverageV8ConflictWarning: false",
-              "suggestion 2": `force coverage using istanbul with coverageMethodForBrowsers: "istanbul"`,
+                "disable this warning with coverage.v8ConflictWarning: false",
+              "suggestion 2": `force coverage using istanbul with coverage.methodForBrowsers: "istanbul"`,
             },
           ),
         );

package/src/coverage/v8_coverage.js

@@ -2,10 +2,10 @@ import { URL_META } from "@jsenv/url-meta";
 
 export const filterV8Coverage = async (
   v8Coverage,
-  { rootDirectoryUrl, coverageConfig },
+  { rootDirectoryUrl, coverageInclude },
 ) => {
   const associations = URL_META.resolveAssociations(
-    { cover: coverageConfig },
+    { cover: coverageInclude },
     rootDirectoryUrl,
   );
   const urlShouldBeCovered = (url) => {

package/src/execution/exception.js

@@ -17,7 +17,15 @@
  * The browser part can be found in "supervisor.js"
  */
 
-export const createException = (reason) => {
+// https://github.com/marvinhagemeister/errorstacks/tree/main
+// https://cdn.jsdelivr.net/npm/errorstacks@latest/dist/esm/index.mjs
+import { parseStackTrace } from "errorstacks";
+import { URL_META } from "@jsenv/url-meta";
+
+const isDev = process.execArgv.includes("--conditions=development");
+const jsenvCoreDirectoryUrl = new URL("../../../../../", import.meta.url);
+
+export const createException = (reason, { rootDirectoryUrl } = {}) => {
   const exception = {
     isException: true,
     isError: false,
@@ -25,6 +33,7 @@ export const createException = (reason) => {
     message: "",
     stack: "",
     stackTrace: "",
+    stackFrames: undefined,
     site: null,
   };
 
@@ -32,88 +41,162 @@ export const createException = (reason) => {
     exception.message = "undefined";
     return exception;
   }
-  if (reason === undefined) {
-    exception.message = "undefined";
+  if (reason === null) {
+    exception.message = "null";
     return exception;
   }
   if (typeof reason === "string") {
     exception.message = reason;
     return exception;
   }
-  if (reason instanceof Error) {
-    exception.isError = true;
-    exception.name = reason.name;
-    exception.message = reason.message;
-    const stackInfo = getStackInfo(reason);
-    if (stackInfo) {
-      const { stackTrace, stackObject } = stackInfo;
-      exception.stackTrace = stackTrace;
-      const [firstCallSite] = stackObject;
-      writePropertiesFromCallSite(exception, firstCallSite);
-    }
-    exception.stack = reason.stack;
-    return exception;
-  }
-  if (typeof reason === "object") {
-    exception.code = reason.code;
-    exception.message = reason.message;
-    exception.stack = reason.stack;
+  if (typeof reason !== "object") {
+    exception.message = JSON.stringify(reason);
     return exception;
   }
-  exception.message = JSON.stringify(reason);
-  return exception;
-};
+  if (reason.stackFrames === undefined && "stack" in reason) {
+    let stackFrames;
 
-const getStackInfo = (reason) => {
-  if (reason instanceof Error) {
     const { prepareStackTrace } = Error;
-    let stackTrace;
-    let stackObject;
-    Error.prepareStackTrace = (e, secondArg) => {
+    Error.prepareStackTrace = (e, callSites) => {
       Error.prepareStackTrace = prepareStackTrace;
-      stackObject = secondArg;
-      stackTrace = secondArg.map((callSite) => `  at ${callSite}`).join("\n");
-      const name = e.name || "Error";
-      const message = e.message || "";
-      let stack = `${name}: ${message}`;
-      if (stackTrace) {
-        stack += `\n${stackTrace}`;
+
+      stackFrames = [];
+      for (const callSite of callSites) {
+        const stackFrame = {
+          raw: `  at ${String(callSite)}`,
+          url: callSite.getFileName() || callSite.getScriptNameOrSourceURL(),
+          line: callSite.getLineNumber(),
+          column: callSite.getColumnNumber(),
+          functionName: callSite.getFunctionName(),
+          isNative: callSite.isNative(),
+          isEval: callSite.isEval(),
+          isConstructor: callSite.isConstructor(),
+          isAsync: callSite.isAsync(),
+          evalSite: null,
+        };
+        if (stackFrame.isEval) {
+          const evalOrigin = stackFrame.getEvalOrigin();
+          if (evalOrigin) {
+            stackFrame.evalSite = getPropertiesFromEvalOrigin(evalOrigin);
+          }
+        }
+        stackFrames.push(stackFrame);
       }
-      return stack;
+      return "";
     };
-    // eslint-disable-next-line no-unused-expressions
-    reason.stack;
-    if (stackTrace === undefined) {
-      return null;
+    exception.stack = reason.stack;
+    if (stackFrames === undefined) {
+      // Error.prepareStackTrace not trigerred
+      // - reason is not an error
+      // - reason.stack already get
+      Error.prepareStackTrace = prepareStackTrace;
+
+      const calls = parseStackTrace(reason.stack);
+      stackFrames = [];
+      for (const call of calls) {
+        if (call.fileName === "") {
+          continue;
+        }
+        stackFrames.push({
+          raw: call.raw,
+          functionName: call.name,
+          url: call.fileName,
+          line: call.line,
+          column: call.column,
+          native: call.type === "native",
+        });
+      }
+    }
+
+    const stackFramesNonNative = [];
+    for (const stackFrame of stackFrames) {
+      if (stackFrame.url.startsWith("node:")) {
+        stackFrame.native = "node";
+        continue;
+      }
+      if (stackFrame.url.startsWith("file:")) {
+        if (rootDirectoryUrl && stackFrame.url.startsWith(rootDirectoryUrl)) {
+          stackFramesNonNative.push(stackFrame);
+          continue;
+        }
+
+        if (isDev) {
+          // while developing jsenv itself we want to exclude any
+          // - src/*
+          // - packages/**/src/
+          // for the users of jsenv it's easier, we want to exclude
+          // - **/node_modules/@jsenv/**
+          if (
+            URL_META.matches(stackFrame.url, {
+              [`${jsenvCoreDirectoryUrl}src/`]: true,
+              [`${jsenvCoreDirectoryUrl}packages/**/src/`]: true,
+            })
+          ) {
+            stackFrame.native = "jsenv";
+            continue;
+          }
+        } else if (
+          URL_META.matches(stackFrame.url, {
+            "file:///**/node_modules/@jsenv/core/": true,
+          })
+        ) {
+          stackFrame.native = "jsenv";
+          continue;
+        }
+      }
+      stackFramesNonNative.push(stackFrame);
+    }
+    if (stackFramesNonNative.length) {
+      stackFrames = stackFramesNonNative;
+    }
+
+    reason.stackFrames = stackFrames;
+
+    let stackTrace = "";
+    for (const stackFrame of stackFrames) {
+      if (stackTrace) stackTrace += "\n";
+      stackTrace += stackFrame.raw;
+    }
+    reason.stackTrace = stackTrace;
+    let stack = "";
+    const name = reason.name || "Error";
+    const message = reason.message || "";
+    stack += `${name}: ${message}`;
+    if (stackTrace) {
+      stack += `\n${stackTrace}`;
+    }
+    reason.stack = stack;
+
+    const [firstCallFrame] = stackFrames;
+    if (firstCallFrame && (!reason.site || !reason.site.isInline)) {
+      reason.site = firstCallFrame.url
+        ? {
+            url: firstCallFrame.url,
+            line: firstCallFrame.line,
+            column: firstCallFrame.column,
+          }
+        : firstCallFrame.evalSite;
     }
-    return {
-      stackTrace,
-      stackObject,
-    };
   }
-  return null;
-};
-const writePropertiesFromCallSite = (exception, callSite) => {
-  const source = callSite.getFileName() || callSite.getScriptNameOrSourceURL();
-  if (source) {
-    const line = callSite.getLineNumber();
-    const column = callSite.getColumnNumber() - 1;
-    exception.site = {
-      url: source,
-      line,
-      column,
-    };
-    return;
+  // getOwnPropertyNames to catch non enumerable properties on reason
+  // (happens mostly when reason is instanceof Error)
+  // like .stack, .message
+  // some properties are even on the prototype like .name
+  for (const ownPropertyName of Object.getOwnPropertyNames(reason)) {
+    exception[ownPropertyName] = reason[ownPropertyName];
   }
-  // Code called using eval() needs special handling
-  if (callSite.isEval()) {
-    const origin = callSite.getEvalOrigin();
-    if (origin) {
-      writePropertiesFromEvalOrigin(exception, origin);
-    }
+  const isError = reason instanceof Error;
+  exception.isError = isError;
+  if (isError) {
+    // getOwnPropertyNames is not enough to copy .name and .message
+    // on error instances
+    exception.name = reason.name;
+    exception.message = reason.message;
   }
+  return exception;
 };
-const writePropertiesFromEvalOrigin = (exception, origin) => {
+
+const getPropertiesFromEvalOrigin = (origin) => {
   // Most eval() calls are in this format
   const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
     origin,
@@ -122,16 +205,16 @@ const writePropertiesFromEvalOrigin = (exception, origin) => {
     const source = topLevelEvalMatch[2];
     const line = Number(topLevelEvalMatch[3]);
     const column = topLevelEvalMatch[4] - 1;
-    exception.site = {
+    return {
       url: source,
       line,
       column,
     };
-    return;
   }
   // Parse nested eval() calls using recursion
   const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
   if (nestedEvalMatch) {
-    writePropertiesFromEvalOrigin(exception, nestedEvalMatch[2]);
+    return getPropertiesFromEvalOrigin(nestedEvalMatch[2]);
   }
+  return null;
 };

package/src/execution/execute.js

@@ -14,13 +14,14 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
 import { createLogger } from "@jsenv/log";
 
-import { createTeardown } from "../helpers/teardown.js";
 import { assertAndNormalizeWebServer } from "./web_server_param.js";
 import { run } from "./run.js";
 
 export const execute = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
+  handleSIGUP = true,
+  handleSIGTERM = true,
   logLevel,
   rootDirectoryUrl,
   webServer,
@@ -31,10 +32,12 @@ export const execute = async ({
   mirrorConsole = true,
   keepRunning = false,
 
-  collectConsole,
-  collectCoverage,
-  coverageTempDirectoryUrl,
+  collectConsole = false,
+  measureMemoryUsage = false,
+  onMeasureMemoryAvailable,
   collectPerformance = false,
+  collectCoverage = false,
+  coverageTempDirectoryUrl,
   runtime,
   runtimeParams,
 
@@ -45,14 +48,16 @@ export const execute = async ({
     rootDirectoryUrl,
     "rootDirectoryUrl",
   );
-  const teardown = createTeardown();
+  const teardownCallbackSet = new Set();
   const executeOperation = Abort.startOperation();
   executeOperation.addAbortSignal(signal);
-  if (handleSIGINT) {
+  if (handleSIGINT || handleSIGUP || handleSIGTERM) {
     executeOperation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
         {
-          SIGINT: true,
+          SIGINT: handleSIGINT,
+          SIGHUP: handleSIGUP,
+          SIGTERM: handleSIGTERM,
         },
         abort,
       );
@@ -60,7 +65,11 @@ export const execute = async ({
   }
 
   if (runtime.type === "browser") {
-    await assertAndNormalizeWebServer(webServer, { signal, teardown, logger });
+    await assertAndNormalizeWebServer(webServer, {
+      signal,
+      teardownCallbackSet,
+      logger,
+    });
   }
 
   let resultTransformer = (result) => result;
@@ -69,7 +78,7 @@ export const execute = async ({
     webServer,
     fileRelativeUrl,
     importMap,
-    teardown,
+    teardownCallbackSet,
     ...runtimeParams,
   };
 
@@ -80,9 +89,11 @@ export const execute = async ({
     keepRunning,
     mirrorConsole,
     collectConsole,
+    measureMemoryUsage,
+    onMeasureMemoryAvailable,
+    collectPerformance,
     collectCoverage,
     coverageTempDirectoryUrl,
-    collectPerformance,
     runtime,
     runtimeParams,
   });
@@ -109,7 +120,9 @@ export const execute = async ({
     }
     return result;
   } finally {
-    await teardown.trigger();
+    for (const teardownCallback of teardownCallbackSet) {
+      await teardownCallback();
+    }
     await executeOperation.end();
   }
 };