@jsenv/snapshot 2.8.9 → 2.8.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.8.9",
+  "version": "2.8.10",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -33,7 +33,7 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/assert": "4.1.15",
+    "@jsenv/assert": "4.2.0",
     "@jsenv/ast": "6.2.16",
     "@jsenv/exception": "1.1.0",
     "@jsenv/filesystem": "4.10.0",

package/src/replace_fluctuating_values.js

@@ -38,8 +38,8 @@ export const replaceFluctuatingValues = (
       const extension = urlToExtension(fileUrl);
       if (extension === ".html") {
         stringType = "html";
-      } else if (extension === ".svg") {
-        stringType = "svg";
+      } else if (extension === ".svg" || extension === ".xml") {
+        stringType = "xml";
       } else if (extension === ".json" || CONTENT_TYPE.isJson(contentType)) {
         stringType = "json";
       }
@@ -92,10 +92,10 @@ export const replaceFluctuatingValues = (
       const replaced = replaceInObject(jsValue, { replace: replaceThings });
       return JSON.stringify(replaced, null, "  ");
     }
-    if (stringType === "html" || stringType === "svg") {
+    if (stringType === "html" || stringType === "xml") {
       // do parse html
       const htmlAst =
-        stringType === "svg"
+        stringType === "xml"
           ? parseSvgString(value)
           : parseHtml({
               html: value,
@@ -112,7 +112,14 @@ export const replaceFluctuatingValues = (
           const attributes = getHtmlNodeAttributes(node);
           if (attributes) {
             for (const name of Object.keys(attributes)) {
-              attributes[name] = replaceThings(attributes[name]);
+              const attributeValue = attributes[name];
+              if (name === "timestamp") {
+                attributes[name] = "[timestamp]";
+              } else if (name === "time") {
+                attributes[name] = "[time]";
+              } else {
+                attributes[name] = replaceThings(attributeValue);
+              }
             }
             setHtmlNodeAttributes(node, attributes);
           }

package/src/side_effects/log/log_side_effects.js

@@ -5,7 +5,31 @@ import { groupLogSideEffects } from "./group_log_side_effects.js";
 const logSideEffectsOptionsDefault = {
   prevent: true,
   group: true,
-  ignore: false,
+  level: "info", // "debug", "trace", "info", "warn", "error", "off"
+  onlyIfLevel: "debug",
+};
+
+export const isLogSideEffect = (sideEffect) => {
+  const { type } = sideEffect;
+  return typeof typeToLevelMap[type] === "number";
+};
+const typeToLevelMap = {
+  "console.debug": 0,
+  "console.trace": 1,
+  "console.info": 2,
+  "console.log": 2,
+  "process.stdout": 2,
+  "console.warn": 3,
+  "console.error": 4,
+  "process.stderr": 4,
+};
+const levelNumberMap = {
+  debug: 0,
+  trace: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+  off: 5,
 };
 
 export const logSideEffects = (logSideEffectsOptions) => {
@@ -16,7 +40,30 @@ export const logSideEffects = (logSideEffectsOptions) => {
   return {
     name: "console",
     install: (addSideEffect, { addFinallyCallback }) => {
-      const { prevent, group, ignore } = logSideEffectsOptions;
+      const { level, prevent, group, onlyIfLevel } = logSideEffectsOptions;
+      const levelNumber = levelNumberMap[level];
+      if (onlyIfLevel && onlyIfLevel !== "debug") {
+        const onlyIfLevelNumber = levelNumberMap[onlyIfLevel];
+        addFinallyCallback((sideEffects) => {
+          const logSideEffects = [];
+          let hasOneOfLevelOrAbove;
+          for (const sideEffect of sideEffects) {
+            if (!isLogSideEffect(sideEffect)) {
+              continue;
+            }
+            logSideEffects.push(sideEffect);
+            if (!hasOneOfLevelOrAbove) {
+              const sideEffectLevel = typeToLevelMap[sideEffect.type];
+              hasOneOfLevelOrAbove = sideEffectLevel >= onlyIfLevelNumber;
+            }
+          }
+          if (!hasOneOfLevelOrAbove) {
+            for (const logSideEffect of logSideEffects) {
+              sideEffects.removeSideEffect(logSideEffect);
+            }
+          }
+        });
+      }
       if (group) {
         addFinallyCallback((sideEffects) => {
           groupLogSideEffects(sideEffects, {
@@ -60,8 +107,23 @@ export const logSideEffects = (logSideEffectsOptions) => {
           });
         });
       }
+
       const addLogSideEffect = (type, message) => {
-        if (ignore) {
+        const sideEffectLevel = typeToLevelMap[type];
+        if (sideEffectLevel < levelNumber) {
+          return;
+        }
+        message = String(message);
+        // some messages are flaky by definition we don't want to
+        // fail on thoose
+        if (
+          message.includes(
+            "GL Driver Message (OpenGL, Performance, GL_CLOSE_PATH_NV, High): GPU stall due to ReadPixels",
+          )
+        ) {
+          return;
+        }
+        if (message.includes("task queue exceeded allotted deadline by")) {
           return;
         }
         addSideEffect({

package/src/side_effects/render_logs_gif.js

@@ -1,12 +1,13 @@
 import { writeFileSync } from "@jsenv/filesystem";
 import { startTerminalRecording } from "@jsenv/terminal-recorder";
+import { isLogSideEffect } from "./log/log_side_effects.js";
 
 export const renderLogsGif = async (sideEffects, gitFileUrl) => {
   const terminalRecorder = await startTerminalRecording({
     gif: true,
   });
   for (const sideEffect of sideEffects) {
-    if (sideEffect.type === "console.log") {
+    if (isLogSideEffect(sideEffect)) {
       await terminalRecorder.write(sideEffect.value, {
         delay: sideEffect.delay,
       });

package/src/side_effects/render_side_effects.js

@@ -37,9 +37,11 @@ export const createBigSizeEffect =
 export const renderSideEffects = (
   sideEffects,
   {
+    sourceFileUrl,
     sideEffectMdFileUrl,
     generateOutFileUrl,
     generatedBy = true,
+    title,
     titleLevel = 1,
     getBigSizeEffect = createBigSizeEffect({
       details: { line: 15, length: 2000 },
@@ -63,6 +65,8 @@ export const renderSideEffects = (
   };
 
   let markdown = "";
+  markdown += `# [${title}](${urlToRelativeUrl(sourceFileUrl, sideEffectMdFileUrl, { preferRelativeNotation: true })})`;
+  markdown += "\n\n";
   let sideEffectNumber = 0;
   for (const sideEffect of sideEffects) {
     if (sideEffect.skippable) {
@@ -76,14 +80,15 @@ export const renderSideEffects = (
   }
   const lastSideEffectNumber = sideEffectNumber;
 
+  let sideEffectMd = "";
   for (const sideEffect of sideEffects) {
     if (sideEffect.skippable) {
       continue;
     }
-    if (markdown) {
-      markdown += "\n\n";
+    if (sideEffectMd) {
+      sideEffectMd += "\n\n";
     }
-    markdown += renderOneSideEffect(sideEffect, {
+    sideEffectMd += renderOneSideEffect(sideEffect, {
       sideEffectMdFileUrl,
       generateOutFileUrl,
       rootDirectoryUrl,
@@ -94,22 +99,40 @@ export const renderSideEffects = (
       lastSideEffectNumber,
     });
   }
+  markdown += sideEffectMd;
   if (generatedBy) {
-    let generatedByLink = renderSmallLink(
+    markdown += "\n";
+    markdown += "---";
+    markdown += "\n\n";
+    markdown += renderSmallLink(
       {
         text: "@jsenv/snapshot",
         href: "https://github.com/jsenv/core/tree/main/packages/independent/snapshot",
       },
-      {
-        prefix: "Generated by ",
-      },
+      { prefix: "Generated by " },
     );
-    markdown += "\n\n";
-    markdown += generatedByLink;
   }
   return markdown;
 };
 
+export const renderInfosTableMd = (infos) => {
+  const infoKeys = Object.keys(infos);
+  if (infoKeys.length === 0) {
+    return "";
+  }
+  let infoTableMd = "";
+  infoTableMd += "\n";
+  infoTableMd += `Infos |  `;
+  infoTableMd += "\n";
+  infoTableMd += `----- | ------`;
+  for (const key of infoKeys) {
+    infoTableMd += "\n";
+    infoTableMd += `${key} | ${infos[key]}`;
+  }
+  infoTableMd += "\n";
+  return infoTableMd;
+};
+
 export const renderSmallLink = (
   link,
   { prefix = "", suffix = "", indent } = {},

package/src/side_effects/snapshot_side_effects.js

@@ -60,6 +60,8 @@ export const snapshotSideEffects = (
   const outDirectorySnapshot = takeDirectorySnapshot(outDirectoryUrl);
   const onSideEffects = (sideEffects) => {
     const sideEffectFileContent = renderSideEffects(sideEffects, {
+      sourceFileUrl,
+      title: urlToFilename(sourceFileUrl),
       sideEffectMdFileUrl,
       generateOutFileUrl,
       errorTransform,

package/src/side_effects/snapshot_tests.js

@@ -37,8 +37,6 @@ export const snapshotTests = async (
     },
     rootDirectoryUrl,
     generatedBy = true,
-    linkToSource = true,
-    linkToEachSource,
     errorTransform,
     logEffects,
     filesystemEffects,
@@ -47,7 +45,7 @@ export const snapshotTests = async (
 ) => {
   filesystemActions = {
     ...filesystemActions,
-    "**/*.svg": "presence_only",
+    "**/*.svg": "compare_presence_only",
   };
 
   const sourceName = urlToBasename(sourceFileUrl, true);
@@ -67,42 +65,32 @@ export const snapshotTests = async (
 
   const dirUrlMap = new Map();
   const sideEffectsMap = new Map();
-  const testMap = new Map();
-  const onlyTestMap = new Map();
+  const testArray = [];
+  let index = 0;
+  let hasOnly = false;
   const test = (scenario, fn, options) => {
-    if (testMap.has(scenario) || onlyTestMap.has(scenario)) {
-      console.warn(`test override "${scenario}"`);
-    }
-    testMap.set(scenario, { fn, options, callSite: getCallerLocation(2) });
+    testArray.push({
+      index,
+      scenario,
+      fn,
+      options,
+      callSite: getCallerLocation(2),
+    });
+    index++;
   };
   test.ONLY = (scenario, fn, options) => {
-    if (testMap.has(scenario) || onlyTestMap.has(scenario)) {
-      console.warn(`test override "${scenario}"`);
-    }
-    onlyTestMap.set(scenario, { fn, options, callSite: getCallerLocation(2) });
+    hasOnly = true;
+    testArray.push({
+      index,
+      scenario,
+      fn,
+      options,
+      callSite: getCallerLocation(2),
+      only: true,
+    });
+    index++;
   };
   const fnReturnValue = await fnRegisteringTest({ test });
-
-  let activeTestMap;
-  const toIgnoreActions = {};
-  if (onlyTestMap.size) {
-    activeTestMap = onlyTestMap;
-    for (const [scenario] of testMap) {
-      const testScenario = asValidFilename(scenario);
-      const generateScenarioOutFileUrl = (outfilename) => {
-        return generateOutFileUrl(`${testScenario}/${outfilename}`);
-      };
-      const scenarioOutDirectoryUrl = generateScenarioOutFileUrl("");
-      toIgnoreActions[scenarioOutDirectoryUrl] = "ignore";
-    }
-  } else {
-    activeTestMap = testMap;
-  }
-  // ignore tout ceux aui sont désactivé
-  const outDirectorySnapshot = takeDirectorySnapshot(outDirectoryUrl, {
-    ...filesystemActions,
-    ...toIgnoreActions,
-  });
   const captureSideEffects = createCaptureSideEffects({
     sourceFileUrl,
     rootDirectoryUrl,
@@ -110,50 +98,79 @@ export const snapshotTests = async (
     filesystemEffects,
     filesystemActions,
   });
+  const sourceRelativeUrl = urlToRelativeUrl(
+    sourceFileUrl,
+    sideEffectMdFileUrl,
+    {
+      preferRelativeNotation: true,
+    },
+  );
   let markdown = "";
-  markdown += `# ${sourceName}`;
-  if (generatedBy) {
-    let generatedByLink = renderSmallLink(
-      {
-        text: "@jsenv/snapshot",
-        href: "https://github.com/jsenv/core/tree/main/packages/independent/snapshot",
-      },
-      {
-        prefix: "Generated by ",
-        suffix:
-          linkToSource && sourceFileUrl
-            ? generateExecutingLink(sourceFileUrl, sideEffectMdFileUrl)
-            : "",
-      },
+  markdown += `# [${urlToFilename(sourceFileUrl)}](${sourceRelativeUrl})`;
+  markdown += `\n\n`;
+  let testMd = "";
+  testMd += `\n\n`;
+  let outDirectorySnapshot;
+  if (testArray.length === 0) {
+    outDirectorySnapshot = takeDirectorySnapshot(
+      outDirectoryUrl,
+      filesystemActions,
     );
-    markdown += "\n\n";
-    markdown += generatedByLink;
-  }
-  const scenarioDirs = [];
-  for (const [scenario, { fn, callSite }] of activeTestMap) {
-    markdown += "\n\n";
-    markdown += `## ${scenario}`;
-    markdown += "\n\n";
-    const sideEffects = await captureSideEffects(fn, {
-      callSite: linkToEachSource ? callSite : undefined,
-      baseDirectory: String(new URL("./", callSite.url)),
-    });
-    sideEffectsMap.set(scenario, sideEffects);
-    const testScenario = asValidFilename(scenario);
-    scenarioDirs.push(testScenario);
-    const generateScenarioOutFileUrl = (outfilename) => {
-      return generateOutFileUrl(`${testScenario}/${outfilename}`);
-    };
-    const scenarioOutDirectoryUrl = generateScenarioOutFileUrl("");
-    dirUrlMap.set(scenario, scenarioOutDirectoryUrl);
-    const sideEffectsMarkdown = renderSideEffects(sideEffects, {
-      sideEffectMdFileUrl,
-      generateOutFileUrl: generateScenarioOutFileUrl,
-      generatedBy: false,
-      titleLevel: 3,
-      errorTransform,
+    testMd += "No test";
+    testMd += "\n";
+  } else {
+    let allTestMd = "";
+    const scenarioDirs = [];
+    const scenarioIgnoreActions = {};
+    const testToExecuteArray = [];
+    for (const testRegistered of testArray) {
+      const { scenario, only } = testRegistered;
+      const scenarioFilename = asValidFilename(scenario);
+      scenarioDirs.push(scenarioFilename);
+      const generateScenarioOutFileUrl = (outFilename) => {
+        return generateOutFileUrl(`${scenarioFilename}/${outFilename}`);
+      };
+      const scenarioOutDirectoryUrl = generateScenarioOutFileUrl("");
+      dirUrlMap.set(scenario, scenarioOutDirectoryUrl);
+      const scenarioMdFileUrl = generateScenarioOutFileUrl(
+        `${scenarioFilename}.md`,
+      );
+      allTestMd += `- [${scenario}](${urlToRelativeUrl(scenarioMdFileUrl, sideEffectMdFileUrl)})`;
+      allTestMd += "\n";
+      if (hasOnly && !only) {
+        scenarioIgnoreActions[scenarioOutDirectoryUrl] = "ignore";
+        continue;
+      }
+      testRegistered.generateScenarioOutFileUrl = generateScenarioOutFileUrl;
+      testRegistered.scenarioMdFileUrl = scenarioMdFileUrl;
+      testToExecuteArray.push(testRegistered);
+    }
+    outDirectorySnapshot = takeDirectorySnapshot(outDirectoryUrl, {
+      ...filesystemActions,
+      ...scenarioIgnoreActions,
     });
-    markdown += sideEffectsMarkdown;
+    for (const testToExecute of testToExecuteArray) {
+      const {
+        scenario,
+        fn,
+        callSite,
+        scenarioMdFileUrl,
+        generateScenarioOutFileUrl,
+      } = testToExecute;
+      const sideEffects = await captureSideEffects(fn, {
+        baseDirectory: String(new URL("./", callSite.url)),
+      });
+      sideEffectsMap.set(scenario, sideEffects);
+      const sideEffectsMarkdown = renderSideEffects(sideEffects, {
+        sourceFileUrl: `${callSite.url}#L${callSite.line}`,
+        sideEffectMdFileUrl: scenarioMdFileUrl,
+        generateOutFileUrl: generateScenarioOutFileUrl,
+        title: scenario,
+        errorTransform,
+      });
+      writeFileSync(scenarioMdFileUrl, sideEffectsMarkdown);
+    }
+    testMd += allTestMd;
   }
   if (typeof fnReturnValue === "function") {
     await fnReturnValue();
@@ -174,21 +191,25 @@ export const snapshotTests = async (
   //     });
   //   }
   // }
+  markdown += testMd;
+  if (generatedBy) {
+    markdown += "\n";
+    markdown += "---";
+    markdown += "\n\n";
+    markdown += renderSmallLink(
+      {
+        text: "@jsenv/snapshot",
+        href: "https://github.com/jsenv/core/tree/main/packages/independent/snapshot",
+      },
+      { prefix: "Generated by " },
+    );
+  }
   writeFileSync(sideEffectMdFileUrl, markdown);
   outDirectorySnapshot.compare(throwWhenDiff);
 
   return { dirUrlMap, sideEffectsMap };
 };
 
-const generateExecutingLink = (sourceFileUrl, sideEffectFileUrl) => {
-  const relativeUrl = urlToRelativeUrl(sourceFileUrl, sideEffectFileUrl, {
-    preferRelativeNotation: true,
-  });
-  const href = `${relativeUrl}`;
-  const text = `${relativeUrl}`;
-  return ` executing <a href="${href}">${text}</a>`;
-};
-
 // see https://github.com/parshap/node-sanitize-filename/blob/master/index.js
 const asValidFilename = (string) => {
   return string