@jsenv/test 1.6.9 → 1.7.0

package/dist/{controllable_child_process.mjs → node_child_process_controlled.mjs}

@@ -1,4 +1,4 @@
-import { uneval, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { createException, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
 import "node:fs";
 import "node:inspector";
 import "node:perf_hooks";
@@ -28,20 +28,13 @@ const ACTION_RESPONSE_STATUS_FAILED = "action-failed";
 const ACTION_RESPONSE_STATUS_COMPLETED = "action-completed";
 
 const sendActionFailed = (error) => {
-  if (error.hasOwnProperty("toString")) {
-    delete error.toString;
-  }
+  const exception = createException(error);
   sendToParent(
     ACTION_RESPONSE_EVENT_NAME,
-    // process.send algorithm does not send non enumerable values
-    // so use @jsenv/uneval
-    uneval(
-      {
-        status: ACTION_RESPONSE_STATUS_FAILED,
-        value: error,
-      },
-      { ignoreSymbols: true },
-    ),
+    JSON.stringify({
+      status: ACTION_RESPONSE_STATUS_FAILED,
+      value: exception,
+    }),
   );
 };
 

package/dist/{controllable_worker_thread.mjs → node_worker_thread_controlled.mjs}

@@ -1,5 +1,5 @@
 import { parentPort } from "node:worker_threads";
-import { uneval, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
+import { createException, executeUsingDynamicImport } from "./js/execute_using_dynamic_import.js";
 import "node:fs";
 import "node:inspector";
 import "node:perf_hooks";
@@ -13,20 +13,13 @@ const ACTION_RESPONSE_STATUS_FAILED = "action-failed";
 const ACTION_RESPONSE_STATUS_COMPLETED = "action-completed";
 
 const sendActionFailed = (error) => {
-  if (error.hasOwnProperty("toString")) {
-    delete error.toString;
-  }
+  const exception = createException(error);
   sendToParent(
     ACTION_RESPONSE_EVENT_NAME,
-    // process.send algorithm does not send non enumerable values
-    // so use @jsenv/uneval
-    uneval(
-      {
-        status: ACTION_RESPONSE_STATUS_FAILED,
-        value: error,
-      },
-      { ignoreSymbols: true },
-    ),
+    JSON.stringify({
+      status: ACTION_RESPONSE_STATUS_FAILED,
+      value: exception,
+    }),
   );
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "1.6.9",
+  "version": "1.7.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -37,11 +37,11 @@
     "@jsenv/ast": "5.1.4",
     "@jsenv/filesystem": "4.3.2",
     "@jsenv/log": "3.4.1",
-    "@jsenv/plugin-supervisor": "1.3.4",
+    "@jsenv/plugin-supervisor": "1.3.5",
     "@jsenv/urls": "2.2.1",
     "@jsenv/url-meta": "8.1.0",
-    "@jsenv/uneval": "1.6.0",
     "@jsenv/utils": "2.0.1",
+    "@jsenv/github-check-run": "0.1.0",
     "v8-to-istanbul": "9.1.0",
     "istanbul-lib-coverage": "3.2.0",
     "istanbul-lib-instrument": "6.0.0",

package/src/execution/exception.js

@@ -0,0 +1,137 @@
+/*
+ * Exception are objects used to wrap a value that is thrown
+ * Usually they wrap error but the value can be anything as
+ * throw "toto" can be used in JS
+ *
+ * - provide a common API to interact with value that can be thrown
+ * - enrich usual errors with a bit more information (line, column)
+ * - normalize error properties
+ *   - exception.stackTrace: only the stack trace as string (no error.name or error.message)
+ *   - error.stack: error.name + error.message + error.stackTrace
+ *
+ * It is used mostly internally by jsenv but can also be found
+ * value returned by "executeTestPlan" public export (for failed executions)
+ * and value returned by "execute" public export (when execution fails)
+ *
+ * This file is responsible to wrap error hapenning in Node.js runtime
+ * The browser part can be found in "supervisor.js"
+ */
+
+export const createException = (reason) => {
+  const exception = {
+    isException: true,
+    isError: false,
+    name: "",
+    message: "",
+    stack: "",
+    stackTrace: "",
+    site: null,
+  };
+
+  if (reason === undefined) {
+    exception.message = "undefined";
+    return exception;
+  }
+  if (reason === undefined) {
+    exception.message = "undefined";
+    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;
+    return exception;
+  }
+  exception.message = JSON.stringify(reason);
+  return exception;
+};
+
+const getStackInfo = (reason) => {
+  if (reason instanceof Error) {
+    const { prepareStackTrace } = Error;
+    let stackTrace;
+    let stackObject;
+    Error.prepareStackTrace = (e, secondArg) => {
+      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}`;
+      }
+      return stack;
+    };
+    // eslint-disable-next-line no-unused-expressions
+    reason.stack;
+    if (stackTrace === undefined) {
+      return null;
+    }
+    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;
+  }
+  // Code called using eval() needs special handling
+  if (callSite.isEval()) {
+    const origin = callSite.getEvalOrigin();
+    if (origin) {
+      writePropertiesFromEvalOrigin(exception, origin);
+    }
+  }
+};
+const writePropertiesFromEvalOrigin = (exception, origin) => {
+  // Most eval() calls are in this format
+  const topLevelEvalMatch = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(
+    origin,
+  );
+  if (topLevelEvalMatch) {
+    const source = topLevelEvalMatch[2];
+    const line = Number(topLevelEvalMatch[3]);
+    const column = topLevelEvalMatch[4] - 1;
+    exception.site = {
+      url: source,
+      line,
+      column,
+    };
+    return;
+  }
+  // Parse nested eval() calls using recursion
+  const nestedEvalMatch = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
+  if (nestedEvalMatch) {
+    writePropertiesFromEvalOrigin(exception, nestedEvalMatch[2]);
+  }
+};

package/src/execution/execute_steps.js

@@ -10,7 +10,7 @@ import { ensureEmptyDirectory, writeFileSync } from "@jsenv/filesystem";
 import { reportToCoverage } from "../coverage/report_to_coverage.js";
 import { run } from "./run.js";
 import { ensureGlobalGc } from "./gc.js";
-import { createExecutionLog, createSummaryLog } from "./logs_file_execution.js";
+import { createExecutionLog, formatSummaryLog } from "./logs_file_execution.js";
 
 export const executeSteps = async (
   executionSteps,
@@ -177,6 +177,9 @@ export const executeSteps = async (
           executionResult: {
             status: "executing",
           },
+          counters,
+          timeEllapsed: Date.now() - startMs,
+          memoryHeap: memoryUsage().heapUsed,
         };
         if (typeof executionParams.allocatedMs === "function") {
           executionParams.allocatedMs =
@@ -188,17 +191,10 @@ export const executeSteps = async (
             log: executionLog,
             render: () => {
               return createExecutionLog(beforeExecutionInfo, {
-                counters,
                 logRuntime,
                 logEachDuration,
-                ...(logTimeUsage
-                  ? {
-                      timeEllapsed: Date.now() - startMs,
-                    }
-                  : {}),
-                ...(logMemoryHeapUsage
-                  ? { memoryHeap: memoryUsage().heapUsed }
-                  : {}),
+                logTimeUsage,
+                logMemoryHeapUsage,
               });
             },
           });
@@ -249,7 +245,6 @@ export const executeSteps = async (
           endMs: Date.now(),
           executionResult,
         };
-        afterExecutionCallback(afterExecutionInfo);
 
         if (executionResult.status === "aborted") {
           counters.aborted++;
@@ -266,7 +261,6 @@ export const executeSteps = async (
         if (executionLogsEnabled) {
           const log = createExecutionLog(afterExecutionInfo, {
             logShortForCompletedExecutions,
-            counters,
             logRuntime,
             logEachDuration,
             ...(logTimeUsage
@@ -294,6 +288,7 @@ export const executeSteps = async (
             executionLog = createLog({ newLine: "" });
           }
         }
+        afterExecutionCallback(afterExecutionInfo);
         const isLastExecutionLog = executionIndex === executionSteps.length - 1;
         const cancelRemaining =
           failFast &&
@@ -321,7 +316,7 @@ export const executeSteps = async (
       duration: Date.now() - startMs,
     };
     if (logSummary) {
-      const summaryLog = createSummaryLog(summary);
+      const summaryLog = formatSummaryLog(summary);
       rawOutput += stripAnsi(summaryLog);
       logger.info(summaryLog);
     }

package/src/execution/execute_test_plan.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import stripAnsi from "strip-ansi";
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
 import { URL_META } from "@jsenv/url-meta";
 import { urlToFileSystemPath, urlToRelativeUrl } from "@jsenv/urls";
@@ -7,7 +8,11 @@ import {
   assertAndNormalizeDirectoryUrl,
   assertAndNormalizeFileUrl,
 } from "@jsenv/filesystem";
-import { createLogger, createDetailedMessage } from "@jsenv/log";
+import { createLogger, createDetailedMessage, UNICODE } from "@jsenv/log";
+import {
+  startGithubCheckRun,
+  readGitHubWorkflowEnv,
+} from "@jsenv/github-check-run";
 
 import { createTeardown } from "../helpers/teardown.js";
 import { generateCoverageJsonFile } from "../coverage/coverage_reporter_json_file.js";
@@ -16,6 +21,8 @@ import { generateCoverageTextLog } from "../coverage/coverage_reporter_text_log.
 import { assertAndNormalizeWebServer } from "./web_server_param.js";
 import { executionStepsFromTestPlan } from "./execution_steps.js";
 import { executeSteps } from "./execute_steps.js";
+import { formatExecutionLabel, formatSummary } from "./logs_file_execution.js";
+import { githubAnnotationFromError } from "./github_annotation_from_error.js";
 
 /**
  * Execute a list of files and log how it goes.
@@ -64,6 +71,15 @@ export const executeTestPlan = async ({
   cooldownBetweenExecutions = 0,
   gcBetweenExecutions = logMemoryHeapUsage,
 
+  githubCheckEnabled = Boolean(process.env.GITHUB_WORKFLOW),
+  githubCheckLogLevel,
+  githubCheckName = "Jsenv tests",
+  githubCheckTitle,
+  githubCheckToken,
+  githubCheckRepositoryOwner,
+  githubCheckRepositoryName,
+  githubCheckCommitSha,
+
   coverageEnabled = process.argv.includes("--coverage"),
   coverageConfig = {
     "file:///**/node_modules/": false,
@@ -178,6 +194,47 @@ export const executeTestPlan = async ({
       });
     }
 
+    if (githubCheckEnabled && !process.env.GITHUB_TOKEN) {
+      githubCheckEnabled = false;
+      const suggestions = [];
+      if (process.env.GITHUB_WORKFLOW_REF) {
+        const workflowFileRef = process.env.GITHUB_WORKFLOW_REF;
+        const refsIndex = workflowFileRef.indexOf("@refs/");
+        // see "GITHUB_WORKFLOW_REF" in https://docs.github.com/en/actions/learn-github-actions/variables#default-environment-variables
+        const workflowFilePath =
+          refsIndex === -1
+            ? workflowFileRef
+            : workflowFileRef.slice(0, refsIndex);
+        suggestions.push(`Pass github token in ${workflowFilePath} during job "${process.env.GITHUB_JOB}"
+\`\`\`yml
+env:
+  GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+\`\`\``);
+      }
+      suggestions.push(`Disable github check with githubCheckEnabled: false`);
+      logger.warn(
+        `${
+          UNICODE.WARNING
+        } githubCheckEnabled but process.env.GITHUB_TOKEN is missing.
+Integration with Github check API is disabled
+To fix this warning:
+- ${suggestions.join("\n- ")}
+`,
+      );
+    }
+    if (githubCheckEnabled) {
+      const githubCheckInfoFromEnv = process.env.GITHUB_WORKFLOW
+        ? readGitHubWorkflowEnv()
+        : {};
+      githubCheckToken = githubCheckToken || githubCheckInfoFromEnv.githubToken;
+      githubCheckRepositoryOwner =
+        githubCheckRepositoryOwner || githubCheckInfoFromEnv.repositoryOwner;
+      githubCheckRepositoryName =
+        githubCheckRepositoryName || githubCheckInfoFromEnv.repositoryName;
+      githubCheckCommitSha =
+        githubCheckCommitSha || githubCheckInfoFromEnv.commitSha;
+    }
+
     if (coverageEnabled) {
       if (coverageMethodForBrowsers === undefined) {
         coverageMethodForBrowsers = someHasCoverageV8
@@ -311,6 +368,61 @@ export const executeTestPlan = async ({
     rootDirectoryUrl,
   });
   logger.debug(`${executionSteps.length} executions planned`);
+  let beforeExecutionCallback;
+  let afterExecutionCallback;
+  let afterAllExecutionCallback = () => {};
+  if (githubCheckEnabled) {
+    const githubCheckRun = await startGithubCheckRun({
+      logLevel: githubCheckLogLevel,
+      githubToken: githubCheckToken,
+      repositoryOwner: githubCheckRepositoryOwner,
+      repositoryName: githubCheckRepositoryName,
+      commitSha: githubCheckCommitSha,
+      checkName: githubCheckName,
+      checkTitle: `Tests executions`,
+      checkSummary: `${executionSteps.length} files will be executed`,
+    });
+    afterExecutionCallback = (afterExecutionInfo) => {
+      const summary = stripAnsi(
+        formatExecutionLabel(afterExecutionInfo, {
+          logTimeUsage,
+          logMemoryHeapUsage,
+        }),
+      );
+      const annotations = [];
+      const { executionResult } = afterExecutionInfo;
+      const { errors = [] } = executionResult;
+      for (const error of errors) {
+        const annotation = githubAnnotationFromError(error, {
+          rootDirectoryUrl,
+          executionInfo: afterExecutionInfo,
+        });
+        annotations.push(annotation);
+      }
+      githubCheckRun.progress({
+        title: "Jsenv test executions",
+        summary,
+        annotations,
+      });
+    };
+    afterAllExecutionCallback = async ({ testPlanSummary }) => {
+      const title = "Jsenv test results";
+      const summary = stripAnsi(formatSummary(testPlanSummary));
+      if (
+        testPlanSummary.counters.total !== testPlanSummary.counters.completed
+      ) {
+        await githubCheckRun.fail({
+          title,
+          summary,
+        });
+        return;
+      }
+      await githubCheckRun.pass({
+        title,
+        summary,
+      });
+    };
+  }
 
   const result = await executeSteps(executionSteps, {
     signal,
@@ -335,6 +447,14 @@ export const executeTestPlan = async ({
     cooldownBetweenExecutions,
     gcBetweenExecutions,
 
+    githubCheckEnabled,
+    githubCheckName,
+    githubCheckTitle,
+    githubCheckToken,
+    githubCheckRepositoryOwner,
+    githubCheckRepositoryName,
+    githubCheckCommitSha,
+
     coverageEnabled,
     coverageConfig,
     coverageIncludeMissing,
@@ -342,11 +462,14 @@ export const executeTestPlan = async ({
     coverageMethodForNodeJs,
     coverageV8ConflictWarning,
     coverageTempDirectoryUrl,
+
+    beforeExecutionCallback,
+    afterExecutionCallback,
   });
-  if (
-    updateProcessExitCode &&
-    result.planSummary.counters.total !== result.planSummary.counters.completed
-  ) {
+
+  const hasFailed =
+    result.planSummary.counters.total !== result.planSummary.counters.completed;
+  if (updateProcessExitCode && hasFailed) {
     process.exitCode = 1;
   }
   const planCoverage = result.planCoverage;
@@ -393,10 +516,13 @@ export const executeTestPlan = async ({
     }
     await Promise.all(promises);
   }
-  return {
+
+  const returnValue = {
     testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,
     testPlanReport: result.planReport,
     testPlanCoverage: planCoverage,
   };
+  await afterAllExecutionCallback(returnValue);
+  return returnValue;
 };

package/src/execution/github_annotation_from_error.js

@@ -0,0 +1,132 @@
+import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
+
+export const githubAnnotationFromError = (
+  error,
+  { rootDirectoryUrl, executionInfo },
+) => {
+  const annotation = {
+    annotation_level: "failure",
+    path: executionInfo.fileRelativeUrl,
+    start_line: 1,
+    end_line: 1,
+    title: `Error while executing ${executionInfo.fileRelativeUrl} on ${executionInfo.runtimeName}@${executionInfo.runtimeVersion}`,
+  };
+  const exception = asException(error, { rootDirectoryUrl });
+  if (typeof exception.site.line === "number") {
+    annotation.path = urlToRelativeUrl(exception.site.url, rootDirectoryUrl);
+    annotation.start_line = exception.site.line;
+    annotation.end_line = exception.site.line;
+    annotation.start_column = exception.site.column;
+    annotation.end_column = exception.site.column;
+  }
+  annotation.message = exception.stack;
+  return annotation;
+};
+
+const asException = (error, { rootDirectoryUrl }) => {
+  const exception = {
+    isException: true,
+    stack: "",
+    site: {},
+  };
+  if (error === null || error === undefined || typeof error === "string") {
+    exception.message = String(error);
+    return exception;
+  }
+  if (error) {
+    exception.message = error.message;
+    if (error.isException) {
+      Object.assign(exception, error);
+      exception.stack = replaceUrls(
+        error.stack,
+        ({ match, url, line = 1, column = 1 }) => {
+          if (urlIsInsideOf(url, rootDirectoryUrl)) {
+            const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+            match = stringifyUrlSite({ url: relativeUrl, line, column });
+          }
+          return match;
+        },
+      );
+    } else if (error.stack) {
+      let firstSite = true;
+      exception.stack = replaceUrls(
+        error.stack,
+        ({ match, url, line = 1, column = 1 }) => {
+          if (urlIsInsideOf(url, rootDirectoryUrl)) {
+            const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl);
+            match = stringifyUrlSite({ url: relativeUrl, line, column });
+          }
+          if (firstSite) {
+            firstSite = false;
+            exception.site.url = url;
+            exception.site.line = line;
+            exception.site.column = column;
+          }
+          return match;
+        },
+      );
+    }
+
+    return exception;
+  }
+  exception.message = error;
+  return exception;
+};
+
+const stringifyUrlSite = ({ url, line, column }) => {
+  let string = url;
+  if (typeof line === "number") {
+    string += `:${line}`;
+    if (typeof column === "number") {
+      string += `:${column}`;
+    }
+  }
+  return string;
+};
+
+const replaceUrls = (source, replace) => {
+  return source.replace(/(?:https?|ftp|file):\/\/\S+/gm, (match) => {
+    let replacement = "";
+    const lastChar = match[match.length - 1];
+
+    // hotfix because our url regex sucks a bit
+    const endsWithSeparationChar = lastChar === ")" || lastChar === ":";
+    if (endsWithSeparationChar) {
+      match = match.slice(0, -1);
+    }
+
+    const lineAndColumnPattern = /:([0-9]+):([0-9]+)$/;
+    const lineAndColumMatch = match.match(lineAndColumnPattern);
+    if (lineAndColumMatch) {
+      const lineAndColumnString = lineAndColumMatch[0];
+      const lineString = lineAndColumMatch[1];
+      const columnString = lineAndColumMatch[2];
+      replacement = replace({
+        match: lineAndColumMatch,
+        url: match.slice(0, -lineAndColumnString.length),
+        line: lineString ? parseInt(lineString) : undefined,
+        column: columnString ? parseInt(columnString) : undefined,
+      });
+    } else {
+      const linePattern = /:([0-9]+)$/;
+      const lineMatch = match.match(linePattern);
+      if (lineMatch) {
+        const lineString = lineMatch[0];
+        replacement = replace({
+          match: lineMatch,
+          url: match.slice(0, -lineString.length),
+          line: lineString ? parseInt(lineString) : undefined,
+        });
+      } else {
+        replacement = replace({
+          match: lineMatch,
+          url: match,
+        });
+      }
+    }
+    if (endsWithSeparationChar) {
+      return `${replacement}${lastChar}`;
+    }
+    return replacement;
+  });
+};