@jsenv/test 2.1.3 → 3.0.1

package/src/execution/format_error_for_terminal.js

@@ -0,0 +1,187 @@
+import { readFileSync } from "node:fs";
+import { inspectFileContent } from "@jsenv/inspect";
+import { urlToFileSystemPath } from "@jsenv/urls";
+import { ANSI } from "@jsenv/log";
+
+export const formatErrorForTerminal = (
+  error,
+  { rootDirectoryUrl, mainFileRelativeUrl, mockFluctuatingValues, tryColors },
+) => {
+  if (!error.stack) {
+    return error.message;
+  }
+
+  let ansiSupported = ANSI.supported;
+  if (!tryColors) {
+    ANSI.supported = false;
+  }
+
+  let text = "";
+  write_code_frame: {
+    if (
+      error.site &&
+      error.site.url &&
+      error.site.url.startsWith("file:") &&
+      typeof error.site.line === "number"
+    ) {
+      const content = readFileSync(new URL(error.site.url), "utf8");
+      text += inspectFileContent({
+        content,
+        line: error.site.line,
+        column: error.site.column,
+        linesAbove: 2,
+        linesBelow: 0,
+        lineMaxWidth: process.stdout.columns,
+        format: (string, type) => {
+          return {
+            line_number_aside: () => ANSI.color(string, ANSI.GREY),
+            char: () => string,
+            marker_overflow_left: () => ANSI.color(string, ANSI.GREY),
+            marker_overflow_right: () => ANSI.color(string, ANSI.GREY),
+            marker_line: () => ANSI.color(string, ANSI.RED),
+            marker_column: () => ANSI.color(string, ANSI.RED),
+          }[type]();
+        },
+      });
+      text += `\n`;
+    }
+  }
+  text += `${error.name}: ${error.message}`;
+  write_stack: {
+    const stringifyUrlSite = ({ url, line, column, urlIsMain }) => {
+      let urlAsPath = String(url).startsWith("file:")
+        ? urlToFileSystemPath(url)
+        : url;
+      if (mockFluctuatingValues) {
+        const rootDirectoryPath = urlToFileSystemPath(rootDirectoryUrl);
+        urlAsPath = urlAsPath.replace(rootDirectoryPath, "[mock]");
+        if (process.platform === "win32") {
+          urlAsPath = urlAsPath.replace(/\\/g, "/");
+        }
+      }
+      if (urlIsMain) {
+        urlAsPath = ANSI.effect(urlAsPath, ANSI.BOLD);
+      }
+      if (typeof line === "number" && typeof column === "number") {
+        return `${urlAsPath}:${line}:${column}`;
+      }
+      if (typeof line === "number") {
+        return `${urlAsPath}:${line}`;
+      }
+      return urlAsPath;
+    };
+
+    let stackTrace = "";
+    const stackFrames = error.stackFrames;
+    if (stackFrames && stackFrames.length) {
+      let atLeastOneNonNative = false;
+      let lastStackFrameForMain;
+      const mainFileUrl = new URL(mainFileRelativeUrl, rootDirectoryUrl).href;
+      for (const stackFrame of stackFrames) {
+        if (stackFrame.url === mainFileUrl) {
+          lastStackFrameForMain = stackFrame;
+        }
+        if (!stackFrame.native) {
+          atLeastOneNonNative = true;
+        }
+      }
+
+      for (const stackFrame of stackFrames) {
+        if (atLeastOneNonNative && stackFrame.native) {
+          continue;
+        }
+        let stackFrameString = stackFrame.raw;
+        stackFrameString = replaceUrls(
+          stackFrameString,
+          ({ url, line, column }) => {
+            const replacement = stringifyUrlSite({
+              url,
+              urlIsMain: stackFrame === lastStackFrameForMain,
+              line,
+              column,
+            });
+            return replacement;
+          },
+        );
+        if (stackTrace) stackTrace += "\n";
+        stackTrace += stackFrameString;
+      }
+    } else if (error.stackTrace) {
+      stackTrace = replaceUrls(error.stackTrace, ({ url, line, column }) => {
+        const replacement = stringifyUrlSite({
+          url,
+          line,
+          column,
+        });
+        return replacement;
+      });
+    } else if (error.site) {
+      stackTrace += `  ${stringifyUrlSite({
+        url: error.site.url,
+        line: error.site.line,
+        column: error.site.column,
+      })}`;
+    }
+
+    if (stackTrace) {
+      text += `\n${stackTrace}`;
+    }
+  }
+
+  if (!tryColors) {
+    ANSI.supported = ansiSupported;
+  }
+
+  return text;
+};
+
+// `Error: yo
+// at Object.execute (http://127.0.0.1:57300/build/src/__test__/file-throw.js:9:13)
+// at doExec (http://127.0.0.1:3000/src/__test__/file-throw.js:452:38)
+// at postOrderExec (http://127.0.0.1:3000/src/__test__/file-throw.js:448:16)
+// at http://127.0.0.1:3000/src/__test__/file-throw.js:399:18`.replace(/(?:https?|ftp|file):\/\/(.*+)$/gm, (...args) => {
+//   debugger
+// })
+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({
+        url: match.slice(0, -lineAndColumnString.length),
+        line: lineString ? parseInt(lineString) : null,
+        column: columnString ? parseInt(columnString) : null,
+      });
+    } else {
+      const linePattern = /:([0-9]+)$/;
+      const lineMatch = match.match(linePattern);
+      if (lineMatch) {
+        const lineString = lineMatch[0];
+        replacement = replace({
+          url: match.slice(0, -lineString.length),
+          line: lineString ? parseInt(lineString) : null,
+        });
+      } else {
+        replacement = replace({
+          url: match,
+        });
+      }
+    }
+    if (endsWithSeparationChar) {
+      return `${replacement}${lastChar}`;
+    }
+    return replacement;
+  });
+};

package/src/execution/github_annotation_from_error.js

@@ -2,14 +2,14 @@ import { urlIsInsideOf, urlToRelativeUrl } from "@jsenv/urls";
 
 export const githubAnnotationFromError = (
   error,
-  { rootDirectoryUrl, executionInfo },
+  { rootDirectoryUrl, execution },
 ) => {
   const annotation = {
     annotation_level: "failure",
-    path: executionInfo.fileRelativeUrl,
+    path: execution.fileRelativeUrl,
     start_line: 1,
     end_line: 1,
-    title: `Error while executing ${executionInfo.fileRelativeUrl} on ${executionInfo.runtimeName}@${executionInfo.runtimeVersion}`,
+    title: `Error while executing ${execution.fileRelativeUrl} on ${execution.runtimeName}@${execution.runtimeVersion}`,
   };
   const exception = asException(error, { rootDirectoryUrl });
   if (exception.site && typeof exception.site.line === "number") {

package/src/execution/junit_xml_file/report_as_junit_xml.js

@@ -0,0 +1,149 @@
+// run prettier on it
+
+// https://github.com/testmoapp/junitxml
+// https://llg.cubic.org/docs/junit/
+
+import { assertAndNormalizeFileUrl, writeFileSync } from "@jsenv/filesystem";
+
+import { formatErrorForTerminal } from "../format_error_for_terminal.js";
+import { createXmlGenerator } from "./xml_generator.js";
+
+export const reportAsJunitXml = async (
+  testPlanResult,
+  fileUrl,
+  { mockFluctuatingValues } = {},
+) => {
+  fileUrl = assertAndNormalizeFileUrl(fileUrl);
+
+  const createRootNode = createXmlGenerator({
+    rootNodeName: "testsuite",
+    canReceiveChildNames: ["testsuite", "testcase", "properties"],
+    canReceiveContentNames: ["failure", "error", "system-out", "system-err"],
+  });
+  const testSuite = createRootNode({
+    time: mockFluctuatingValues ? "[mock]" : testPlanResult.timings.end,
+    timestamp: mockFluctuatingValues
+      ? "[mock]"
+      : new Date(testPlanResult.timings.origin).toISOString().slice(0, -5), //  Date and time of when the test run was executed
+    tests: testPlanResult.counters.planified,
+    skipped:
+      testPlanResult.counters.aborted + testPlanResult.counters.cancelled,
+    failures: testPlanResult.counters.timedout + testPlanResult.counters.failed, // Total number of failed tests
+  });
+
+  for (const fileRelativeUrl of Object.keys(testPlanResult.results)) {
+    const fileResults = testPlanResult.results[fileRelativeUrl];
+    for (const group of Object.keys(fileResults)) {
+      const executionResult = fileResults[group];
+      const testCase = testSuite.createNode("testcase", {
+        file: fileRelativeUrl,
+        name: group,
+        time: mockFluctuatingValues ? "[mock]" : executionResult.timings.end, // duration of this execution
+        timestamp: mockFluctuatingValues
+          ? "[mock]"
+          : new Date(executionResult.timings.origin).toISOString().slice(0, -5), //  Date and time of when the test run was executed
+        tests: 1, // Total number of tests for this execution
+      });
+      testSuite.appendChild(testCase);
+
+      if (executionResult.status === "aborted") {
+        testCase.attributes.skipped = 1;
+        const skipped = testCase.createNode("skipped", {
+          message: "Execution was aborted",
+        });
+        testSuite.appendChild(skipped);
+      }
+      if (executionResult.status === "timedout") {
+        testCase.attributes.failures = 1;
+        const failure = testCase.createNode("failure", {
+          message: `Execution timeout after ${executionResult.params.allocatedMs}ms"`,
+          type: "timeout",
+        });
+        testSuite.appendChild(failure);
+      }
+      if (executionResult.status === "failed") {
+        const [error] = executionResult.errors;
+        if (
+          error &&
+          typeof error.name === "string" &&
+          error.name.includes("AssertionError")
+        ) {
+          testCase.attributes.failures = 1;
+          const failure = testCase.createNode("failure", {
+            type: error.name,
+          });
+          testSuite.appendChild(failure);
+          failure.setContent(
+            formatErrorForTerminal(error, {
+              rootDirectoryUrl: testPlanResult.rootDirectoryUrl,
+              mainFileRelativeUrl: fileRelativeUrl,
+              mockFluctuatingValues,
+              tryColors: false,
+            }),
+          );
+        } else {
+          testCase.attributes.errors = 1;
+          const errorNode = testCase.createNode("error", {
+            type: error.name,
+          });
+          testSuite.appendChild(errorNode);
+          errorNode.setContent(
+            formatErrorForTerminal(error, {
+              rootDirectoryUrl: testPlanResult.rootDirectoryUrl,
+              mainFileRelativeUrl: fileRelativeUrl,
+              mockFluctuatingValues,
+              tryColors: false,
+            }),
+          );
+        }
+      }
+
+      const groupInfo = testPlanResult.groups[group];
+      const properties = {
+        runtimeName: groupInfo.runtimeName,
+        runtimeVersion: mockFluctuatingValues
+          ? "[mock]"
+          : groupInfo.runtimeVersion,
+      };
+      const propertiesNode = testCase.createNode("properties");
+      testCase.appendChild(propertiesNode);
+      for (const propertyName of Object.keys(properties)) {
+        const propertyNode = propertiesNode.createNode("property", {
+          name: propertyName,
+          value: properties[propertyName],
+        });
+        propertiesNode.appendChild(propertyNode);
+      }
+
+      const { consoleCalls } = executionResult;
+      let stdout = "";
+      let stderr = "";
+      for (const consoleCall of consoleCalls) {
+        if (groupInfo.runtimeType === "node") {
+          if (consoleCall.type === "error") {
+            stdout += consoleCall.text;
+          } else {
+            stderr += consoleCall.text;
+          }
+        } else {
+          stdout += consoleCall.text;
+        }
+      }
+      if (stdout.length) {
+        const systemOut = testSuite.createNode("system-out");
+        testCase.appendChild(systemOut);
+        systemOut.setContent(stdout);
+      }
+      if (stderr.length) {
+        const systemErr = testSuite.createNode("system-err");
+        testCase.appendChild(systemErr);
+        systemErr.setContent(stderr);
+      }
+    }
+  }
+
+  let junitXmlFileContent = `<?xml version="1.0" encoding="UTF-8"?>
+${testSuite.renderAsString()}`;
+
+  writeFileSync(new URL(fileUrl), junitXmlFileContent);
+};

package/src/execution/junit_xml_file/xml_generator.js

@@ -0,0 +1,141 @@
+import he from "he";
+
+export const createXmlGenerator = ({
+  rootNodeName,
+  canSelfCloseNames = [],
+  canReceiveChildNames = [],
+  canReceiveContentNames = [],
+}) => {
+  const createNode = (name, attributes = {}) => {
+    const canSelfClose = canSelfCloseNames.includes(name);
+    const canReceiveChild = canReceiveChildNames.includes(name);
+    const canReceiveContent = canReceiveContentNames.includes(name);
+
+    const children = [];
+
+    const node = {
+      name,
+      content: "",
+      children,
+      attributes,
+      canSelfClose,
+      createNode,
+      appendChild: (childNode) => {
+        if (!canReceiveChild) {
+          throw new Error(`cannot appendChild into ${name}`);
+        }
+        children.push(childNode);
+        return childNode;
+      },
+      setContent: (value) => {
+        if (!canReceiveContent) {
+          throw new Error(`cannot setContent on ${name}`);
+        }
+        node.content = value;
+      },
+      renderAsString: () => {
+        const renderNode = (node, { depth }) => {
+          let nodeString = "";
+          nodeString += `<${node.name}`;
+
+          write_attributes: {
+            const attributeNames = Object.keys(node.attributes);
+            if (attributeNames.length) {
+              let attributesSingleLine = "";
+              let attributesMultiLine = "";
+
+              for (const attributeName of attributeNames) {
+                let attributeValue = node.attributes[attributeName];
+                if (typeof attributeValue === "number") {
+                  attributeValue = round(attributeValue);
+                }
+                if (attributeName === "viewBox") {
+                  attributeValue = attributeValue
+                    .split(",")
+                    .map((v) => round(parseFloat(v.trim())))
+                    .join(", ");
+                }
+                attributesSingleLine += ` ${attributeName}="${attributeValue}"`;
+                attributesMultiLine += `\n  `;
+                attributesMultiLine += "  ".repeat(depth);
+                attributesMultiLine += `${attributeName}="${attributeValue}"`;
+              }
+              attributesMultiLine += "\n";
+              attributesMultiLine += "  ".repeat(depth);
+
+              if (attributesSingleLine.length < 100) {
+                nodeString += attributesSingleLine;
+              } else {
+                nodeString += attributesMultiLine;
+              }
+            }
+          }
+
+          let innerHTML = "";
+          if (node.content) {
+            const contentEncoded = he.encode(node.content, { decimal: false });
+            innerHTML += contentEncoded;
+          }
+          write_children: {
+            if (node.children.length > 0) {
+              for (const child of node.children) {
+                innerHTML += "\n  ";
+                innerHTML += "  ".repeat(depth);
+                innerHTML += renderNode(child, {
+                  depth: depth + 1,
+                });
+              }
+              innerHTML += "\n";
+              innerHTML += "  ".repeat(depth);
+            }
+          }
+          if (innerHTML === "") {
+            if (node.canSelfClose) {
+              nodeString += `/>`;
+            } else {
+              nodeString += `></${node.name}>`;
+            }
+          } else {
+            nodeString += `>`;
+            nodeString += innerHTML;
+            nodeString += `</${node.name}>`;
+          }
+          return nodeString;
+        };
+
+        return renderNode(node, {
+          depth: 0,
+        });
+      },
+    };
+
+    return node;
+  };
+
+  return (rootNodeAttributes) => createNode(rootNodeName, rootNodeAttributes);
+};
+
+export const createSvgRootNode = createXmlGenerator({
+  rootNodeName: "svg",
+  canSelfCloseNames: ["path", "rect", "circle"],
+  canReceiveChildNames: ["svg", "foreignObject", "g"],
+  canReceiveContentNames: ["text", "style"],
+});
+
+// not used for now and needs to configure canReceiveChildNames and so on...
+export const createXmlRootNode = createXmlGenerator({
+  rootNodeName: "xml",
+});
+
+// not used for now and needs to configure canReceiveChildNames and so on...
+export const createHtmlRootNode = createXmlGenerator({
+  rootNodeName: "html",
+});
+
+// Round: Make number values smaller in output
+// Eg: 14.23734 becomes 14.24
+// Credit @Chris Martin: https://stackoverflow.com/a/43012696/2816869
+const round = (x) => {
+  const rounded = Number(`${Math.round(`${x}e2`)}e-2`);
+  return rounded;
+};