@jsenv/snapshot 2.2.1 → 2.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.2.1",
+  "version": "2.2.2",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {

package/src/function_snapshot.js

@@ -1,111 +1,97 @@
-import {
-  moveEntrySync,
-  writeDirectorySync,
-  writeFileSync,
-} from "@jsenv/filesystem";
+import { readEntryStatSync, readFileSync } from "@jsenv/filesystem";
 import { urlToRelativeUrl } from "@jsenv/urls/src/url_to_relative_url.js";
-import { takeDirectorySnapshot } from "./filesystem_snapshot.js";
+import { takeFileSnapshot } from "./filesystem_snapshot.js";
 import { replaceFluctuatingValues } from "./replace_fluctuating_values.js";
 
 export const snapshotFunctionSideEffects = (
   fn,
   fnFileUrl,
+  sideEffectFileRelativeUrl,
   {
-    sideEffectDirectoryName = "output",
     rootDirectoryUrl = new URL("./", fnFileUrl),
     captureConsole = true,
     filesystemEffects,
   } = {},
 ) => {
-  const sideEffectDirectoryUrl = new URL(sideEffectDirectoryName, fnFileUrl);
-  writeDirectorySync(sideEffectDirectoryUrl, { allowUseless: true });
-  const sideEffectDirectorySnapshot = takeDirectorySnapshot(
-    sideEffectDirectoryUrl,
-  );
+  const sideEffectFileUrl = new URL(sideEffectFileRelativeUrl, fnFileUrl);
+  const sideEffectFileSnapshot = takeFileSnapshot(sideEffectFileUrl);
+  const sideEffects = [];
   const finallyCallbackSet = new Set();
-  const errorFileUrl = new URL("./error.txt", sideEffectDirectoryUrl);
-  const resultFileUrl = new URL("./result.json", sideEffectDirectoryUrl);
   const onError = (e) => {
-    writeFileSync(
-      errorFileUrl,
-      replaceFluctuatingValues(e.stack, {
-        fileUrl: errorFileUrl,
-      }),
-    );
+    sideEffects.push({
+      type: "throw",
+      value: e,
+    });
   };
   const onResult = (result) => {
-    if (result === undefined) {
-      return;
-    }
-    writeFileSync(
-      resultFileUrl,
-      replaceFluctuatingValues(JSON.stringify(result, null, "  "), {
-        fileUrl: resultFileUrl,
-        rootDirectoryUrl,
-      }),
-    );
+    sideEffects.push({
+      type: "return",
+      value: result,
+    });
   };
   const onFinally = () => {
     for (const finallyCallback of finallyCallbackSet) {
       finallyCallback();
     }
-    sideEffectDirectorySnapshot.compare();
+    sideEffectFileSnapshot.update(
+      stringifySideEffects(sideEffects, { rootDirectoryUrl }),
+    );
+    sideEffectFileSnapshot.compare();
   };
   if (captureConsole) {
-    const installConsoleSpy = (methodName, consoleOutputFileUrl) => {
+    const installConsoleSpy = (methodName) => {
       const methodSpied = console[methodName];
-      let output = "";
       console[methodName] = (message) => {
-        if (output) {
-          output += "\n";
-        }
-        output += message;
+        sideEffects.push({
+          type: `console.${methodName}`,
+          value: message,
+        });
       };
       finallyCallbackSet.add(() => {
         console[methodName] = methodSpied;
-        if (output) {
-          writeFileSync(
-            consoleOutputFileUrl,
-            replaceFluctuatingValues(output, {
-              fileUrl: consoleOutputFileUrl,
-              rootDirectoryUrl,
-            }),
-          );
-        }
       });
     };
-    installConsoleSpy(
-      "error",
-      new URL("./console_errors.txt", sideEffectDirectoryUrl),
-    );
-    installConsoleSpy(
-      "warn",
-      new URL("./console_warnings.txt", sideEffectDirectoryUrl),
-    );
-    installConsoleSpy(
-      "info",
-      new URL("./console_infos.txt", sideEffectDirectoryUrl),
-    );
-    installConsoleSpy(
-      "log",
-      new URL("./console_logs.txt", sideEffectDirectoryUrl),
-    );
+    installConsoleSpy("error");
+    installConsoleSpy("warn");
+    installConsoleSpy("info");
+    installConsoleSpy("log");
   }
   if (filesystemEffects) {
-    const filesystemEffectDirectoryUrl = new URL(
-      "./fs/",
-      sideEffectDirectoryUrl,
-    );
     for (const filesystemEffect of filesystemEffects) {
+      const from = new URL(filesystemEffect, fnFileUrl);
+      const relativeUrl = urlToRelativeUrl(from, fnFileUrl);
+      const atStartState = getFileState(from);
+      const onFileSystemSideEffect = (fsSideEffect) => {
+        const last = sideEffects.pop();
+        sideEffects.push(fsSideEffect);
+        sideEffects.push(last);
+      };
       finallyCallbackSet.add(() => {
-        const from = new URL(filesystemEffect, fnFileUrl);
-        const relativeUrl = urlToRelativeUrl(from, fnFileUrl);
-        moveEntrySync({
-          from,
-          to: new URL(relativeUrl, filesystemEffectDirectoryUrl),
-          noEntryEffect: "none",
-          overwrite: true,
-        });
+        const nowState = getFileState(from);
+        if (atStartState.found && !nowState.found) {
+          onFileSystemSideEffect({
+            type: `remove file "${relativeUrl}"`,
+            value: atStartState.content,
+          });
+          return;
+        }
+        // we use same type because we don't want to differentiate between
+        // - writing file for the 1st time
+        // - updating file content
+        // the important part is the file content in the end of the function execution
+        if (
+          (!atStartState.found && nowState.found) ||
+          atStartState.content !== nowState.content ||
+          atStartState.mtimeMs !== nowState.mtimeMs
+        ) {
+          onFileSystemSideEffect({
+            type: `write file "${relativeUrl}"`,
+            value: nowState.content,
+          });
+          return;
+        }
+        // file is exactly the same
+        // function did not have any effect on the file
       });
     }
   }
@@ -136,3 +122,56 @@ export const snapshotFunctionSideEffects = (
     onFinally();
   }
 };
+
+const stringifySideEffects = (sideEffects, { rootDirectoryUrl }) => {
+  let string = "";
+  let index = 0;
+  for (const sideEffect of sideEffects) {
+    if (string) {
+      string += "\n\n";
+    }
+    string += `${index + 1}. ${sideEffect.type}`;
+    string += "\n";
+    let value = sideEffect.value;
+    if (sideEffect.type === "throw") {
+      value = replaceFluctuatingValues(value.stack, {
+        stringType: "error",
+      });
+    } else if (sideEffect.type === "return") {
+      value =
+        value === undefined
+          ? undefined
+          : replaceFluctuatingValues(JSON.stringify(value, null, "  "), {
+              stringType: "json",
+              rootDirectoryUrl,
+            });
+    } else if (sideEffect.type.startsWith("console.")) {
+      value = replaceFluctuatingValues(value, {
+        stringType: "console",
+        rootDirectoryUrl,
+      });
+    }
+    string += value;
+    index++;
+  }
+  return string;
+};
+
+const getFileState = (fileUrl) => {
+  try {
+    const fileContent = readFileSync(fileUrl);
+    const { mtimeMs } = readEntryStatSync(fileUrl);
+    return {
+      found: true,
+      mtimeMs,
+      content: String(fileContent),
+    };
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return {
+        found: false,
+      };
+    }
+    throw e;
+  }
+};

package/src/replace_fluctuating_values.js

@@ -19,6 +19,7 @@ import stripAnsi from "strip-ansi";
 export const replaceFluctuatingValues = (
   string,
   {
+    stringType,
     fileUrl,
     removeAnsi = true,
     rootDirectoryUrl = pathToFileURL(process.cwd()),
@@ -60,37 +61,42 @@ export const replaceFluctuatingValues = (
     return value;
   };
 
-  if (fileUrl) {
+  if (fileUrl && stringType === undefined) {
     const extension = urlToExtension(fileUrl);
-    if (extension === ".svg" || extension === ".html") {
-      // do parse html
-      const htmlAst =
-        extension === ".svg"
-          ? parseSvgString(string)
-          : parseHtml({
-              html: string,
-              storeOriginalPositions: false,
-            });
-      // for each attribute value
-      // and each text node content
-      visitHtmlNodes(htmlAst, {
-        "*": (node) => {
-          const htmlNodeText = getHtmlNodeText(node);
-          if (htmlNodeText) {
-            setHtmlNodeText(node, replaceThings(htmlNodeText));
-          }
-          const attributes = getHtmlNodeAttributes(node);
-          if (attributes) {
-            for (const name of Object.keys(attributes)) {
-              attributes[name] = replaceThings(attributes[name]);
-            }
-            setHtmlNodeAttributes(node, attributes);
-          }
-        },
-      });
-      return stringifyHtmlAst(htmlAst);
+    if (extension === ".html") {
+      stringType = "html";
+    } else if (extension === ".svg") {
+      stringType = "svg";
     }
   }
+  if (stringType === "html") {
+    // do parse html
+    const htmlAst =
+      stringType === "svg"
+        ? parseSvgString(string)
+        : parseHtml({
+            html: string,
+            storeOriginalPositions: false,
+          });
+    // for each attribute value
+    // and each text node content
+    visitHtmlNodes(htmlAst, {
+      "*": (node) => {
+        const htmlNodeText = getHtmlNodeText(node);
+        if (htmlNodeText) {
+          setHtmlNodeText(node, replaceThings(htmlNodeText));
+        }
+        const attributes = getHtmlNodeAttributes(node);
+        if (attributes) {
+          for (const name of Object.keys(attributes)) {
+            attributes[name] = replaceThings(attributes[name]);
+          }
+          setHtmlNodeAttributes(node, attributes);
+        }
+      },
+    });
+    return stringifyHtmlAst(htmlAst);
+  }
   return replaceThings(string);
 };