@jsenv/snapshot 2.2.8 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.2.8",
+  "version": "2.3.0",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -34,8 +34,9 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/assert": "4.1.5",
+    "@jsenv/assert": "4.1.6",
     "@jsenv/ast": "6.2.6",
+    "@jsenv/exception": "1.0.0",
     "@jsenv/filesystem": "4.9.2",
     "@jsenv/urls": "2.3.2",
     "@jsenv/utils": "2.1.1",

package/src/compare_png_files.js

@@ -20,7 +20,7 @@ export const comparePngFiles = (actualData, expectData) => {
   );
   const diffRatio = numberOfPixelsConsideredAsDiff / numberOfPixels;
   const diffPercentage = diffRatio * 100;
-  return diffPercentage <= 0.5;
+  return diffPercentage <= 1;
 };
 
 const getPngDimensions = (buffer) => {

package/src/function_side_effects/function_side_effects_collector.js

@@ -0,0 +1,132 @@
+import { createException } from "@jsenv/exception";
+import { replaceFluctuatingValues } from "../replace_fluctuating_values.js";
+
+const RETURN_PROMISE = {};
+
+let executing = false;
+export const collectFunctionSideEffects = (
+  fn,
+  sideEffectDetectors,
+  { rootDirectoryUrl },
+) => {
+  if (executing) {
+    throw new Error("collectFunctionSideEffects already running");
+  }
+  const sideEffects = [];
+  const addSideEffect = (sideEffect) => {
+    sideEffects.push(sideEffect);
+  };
+  const finallyCallbackSet = new Set();
+  for (const sideEffectDetector of sideEffectDetectors) {
+    const uninstall = sideEffectDetector.install(addSideEffect);
+    finallyCallbackSet.add(() => {
+      uninstall();
+    });
+  }
+  const onCatch = (valueThrow) => {
+    sideEffects.push({
+      type: "throw",
+      value: valueThrow,
+      label: "throw",
+      text: renderValueThrownOrRejected(
+        createException(valueThrow, { rootDirectoryUrl }),
+        { rootDirectoryUrl },
+      ),
+    });
+  };
+  const onReturn = (valueReturned) => {
+    if (valueReturned === RETURN_PROMISE) {
+      sideEffects.push({
+        type: "return",
+        value: valueReturned,
+        label: "return promise",
+        text: null,
+      });
+    } else {
+      sideEffects.push({
+        type: "return",
+        value: valueReturned,
+        label: "return",
+        text: renderReturnValueOrResolveValue(valueReturned, {
+          rootDirectoryUrl,
+        }),
+      });
+    }
+  };
+  const onResolve = (value) => {
+    sideEffects.push({
+      type: "resolve",
+      value,
+      label: "resolve",
+      text: renderReturnValueOrResolveValue(value, { rootDirectoryUrl }),
+    });
+  };
+  const onReject = (reason) => {
+    sideEffects.push({
+      type: "reject",
+      value: reason,
+      label: "reject",
+      text: renderValueThrownOrRejected(
+        createException(reason, { rootDirectoryUrl }),
+        { rootDirectoryUrl },
+      ),
+    });
+  };
+  const onFinally = () => {
+    executing = false;
+    for (const finallyCallback of finallyCallbackSet) {
+      finallyCallback();
+    }
+    finallyCallbackSet.clear();
+  };
+
+  let returnedPromise = false;
+  try {
+    const valueReturned = fn();
+    if (valueReturned && typeof valueReturned.then === "function") {
+      onReturn(RETURN_PROMISE);
+      returnedPromise = valueReturned.then(
+        (value) => {
+          onResolve(value);
+          onFinally();
+          return sideEffects;
+        },
+        (e) => {
+          onReject(e);
+          onFinally();
+          return sideEffects;
+        },
+      );
+      return returnedPromise;
+    }
+    onReturn(valueReturned);
+    return sideEffects;
+  } catch (e) {
+    onCatch(e);
+    return sideEffects;
+  } finally {
+    if (!returnedPromise) {
+      onFinally();
+    }
+  }
+};
+
+const renderReturnValueOrResolveValue = (value, { rootDirectoryUrl }) => {
+  if (value === undefined) {
+    return "undefined";
+  }
+  return replaceFluctuatingValues(JSON.stringify(value, null, "  "), {
+    stringType: "json",
+    rootDirectoryUrl,
+  });
+};
+
+const renderValueThrownOrRejected = (value, { rootDirectoryUrl }) => {
+  return replaceFluctuatingValues(
+    value ? value.stack || value.message || value : String(value),
+    {
+      stringType: "error",
+      rootDirectoryUrl,
+    },
+  );
+};

package/src/function_side_effects/function_side_effects_renderer.js

@@ -0,0 +1,18 @@
+export const renderSideEffects = (sideEffects) => {
+  let string = "";
+  let index = 0;
+  for (const sideEffect of sideEffects) {
+    if (string) {
+      string += "\n\n";
+    }
+    let label = `${index + 1}. ${sideEffect.label}`;
+    let text = sideEffect.text;
+    string += label;
+    if (text) {
+      string += "\n";
+      string += text;
+    }
+    index++;
+  }
+  return string;
+};

package/src/function_side_effects/function_side_effects_snapshot.js

@@ -0,0 +1,160 @@
+import { writeFileSync } from "@jsenv/filesystem";
+import {
+  ensurePathnameTrailingSlash,
+  urlToFilename,
+  urlToRelativeUrl,
+} from "@jsenv/urls";
+import { takeDirectorySnapshot } from "../filesystem_snapshot.js";
+import { replaceFluctuatingValues } from "../replace_fluctuating_values.js";
+import { collectFunctionSideEffects } from "./function_side_effects_collector.js";
+import { renderSideEffects } from "./function_side_effects_renderer.js";
+import { spyConsoleCalls } from "./spy_console_calls.js";
+import { spyFilesystemCalls } from "./spy_filesystem_calls.js";
+
+let filesystemSideEffectInstalled;
+
+export const snapshotFunctionSideEffects = (
+  fn,
+  fnFileUrl,
+  sideEffectDirectoryRelativeUrl = "./",
+  {
+    rootDirectoryUrl = new URL("./", fnFileUrl),
+    filesystemEffectsDirectory,
+    preventConsoleSideEffects = true,
+    undoFilesystemSideEffects = true,
+  } = {},
+) => {
+  if (filesystemEffectsDirectory === true) {
+    filesystemEffectsDirectory = "./fs/";
+  }
+  const sideEffectDirectoryUrl = new URL(
+    sideEffectDirectoryRelativeUrl,
+    fnFileUrl,
+  );
+  const sideEffectDirectorySnapshot = takeDirectorySnapshot(
+    sideEffectDirectoryUrl,
+  );
+  const sideEffectFilename = `${urlToFilename(sideEffectDirectoryUrl)}_side_effects.txt`;
+  const sideEffectFileUrl = new URL(sideEffectFilename, sideEffectDirectoryUrl);
+  const callbackSet = new Set();
+  const sideEffectDetectors = [
+    {
+      name: "console",
+      install: (addSideEffect) => {
+        const onConsole = (methodName, message) => {
+          addSideEffect({
+            type: `console:${methodName}`,
+            value: message,
+            label: `console.${methodName}`,
+            text: replaceFluctuatingValues(message, {
+              stringType: "console",
+              rootDirectoryUrl,
+            }),
+          });
+        };
+        const consoleSpy = spyConsoleCalls(
+          {
+            error: (message) => {
+              onConsole("error", message);
+            },
+            warn: (message) => {
+              onConsole("warn", message);
+            },
+            info: (message) => {
+              onConsole("info", message);
+            },
+            log: (message) => {
+              onConsole("log", message);
+            },
+          },
+          {
+            preventConsoleSideEffects,
+          },
+        );
+        return () => {
+          consoleSpy.restore();
+        };
+      },
+    },
+    {
+      name: "filesystem",
+      install: (addSideEffect) => {
+        if (filesystemSideEffectInstalled) {
+          throw new Error(
+            "cannot collect filesystem side effects concurrently (already collecting side effect for an other function)",
+          );
+        }
+        filesystemSideEffectInstalled = true;
+        const fsSideEffectDirectoryUrl = ensurePathnameTrailingSlash(
+          new URL(filesystemEffectsDirectory, sideEffectDirectoryUrl),
+        );
+        const fsSideEffectsDirectoryRelativeUrl = urlToRelativeUrl(
+          fsSideEffectDirectoryUrl,
+          sideEffectFileUrl,
+        );
+        const filesystemSpy = spyFilesystemCalls(
+          {
+            writeFile: (url, content) => {
+              const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
+              const toUrl = new URL(relativeUrl, fsSideEffectDirectoryUrl);
+              if (filesystemEffectsDirectory) {
+                callbackSet.add(() => {
+                  writeFileSync(toUrl, content);
+                });
+                addSideEffect({
+                  type: "fs:write_file",
+                  value: { relativeUrl, content },
+                  label: `write file "${relativeUrl}" (see ./${fsSideEffectsDirectoryRelativeUrl}${relativeUrl})`,
+                  text: null,
+                });
+              } else {
+                addSideEffect({
+                  type: "fs:write_file",
+                  value: { relativeUrl, content },
+                  label: `write file "${relativeUrl}"`,
+                  text: content,
+                });
+              }
+            },
+            writeDirectory: (url) => {
+              const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
+              addSideEffect({
+                type: "fs:write_directory",
+                value: { relativeUrl },
+                label: `write directory "${relativeUrl}"`,
+                text: null,
+              });
+            },
+          },
+          {
+            undoFilesystemSideEffects,
+          },
+        );
+        return () => {
+          filesystemSpy.restore();
+          filesystemSideEffectInstalled = false;
+        };
+      },
+    },
+  ];
+
+  const onSideEffectsCollected = (sideEffects) => {
+    for (const callback of callbackSet) {
+      callback();
+    }
+    callbackSet.clear();
+    writeFileSync(sideEffectFileUrl, renderSideEffects(sideEffects));
+    sideEffectDirectorySnapshot.compare();
+  };
+
+  const returnValue = collectFunctionSideEffects(fn, sideEffectDetectors, {
+    rootDirectoryUrl,
+  });
+  if (returnValue && typeof returnValue.then === "function") {
+    return returnValue.then((sideEffects) => {
+      onSideEffectsCollected(sideEffects);
+    });
+  }
+  onSideEffectsCollected(returnValue);
+  return undefined;
+};

package/src/function_side_effects/spy_console_calls.js

@@ -0,0 +1,53 @@
+import { spyMethod } from "./spy_method.js";
+
+export const spyConsoleCalls = (
+  { error, warn, info, log, trace },
+  { preventConsoleSideEffects },
+) => {
+  const restoreCallbackSet = new Set();
+  const errorSpy = spyMethod(console, "error", (message) => {
+    if (preventConsoleSideEffects) {
+      errorSpy.preventOriginalCall();
+    }
+    error(message);
+  });
+  const warnSpy = spyMethod(console, "warn", (message) => {
+    if (preventConsoleSideEffects) {
+      warnSpy.preventOriginalCall();
+    }
+    warn(message);
+  });
+  const infoSpy = spyMethod(console, "info", (message) => {
+    if (preventConsoleSideEffects) {
+      infoSpy.preventOriginalCall();
+    }
+    info(message);
+  });
+  const logSpy = spyMethod(console, "log", (message) => {
+    if (preventConsoleSideEffects) {
+      logSpy.preventOriginalCall();
+    }
+    log(message);
+  });
+  const traceSpy = spyMethod(console, "trace", (message) => {
+    if (preventConsoleSideEffects) {
+      traceSpy.preventOriginalCall();
+    }
+    trace(message);
+  });
+  restoreCallbackSet.add(() => {
+    errorSpy.remove();
+    warnSpy.remove();
+    infoSpy.remove();
+    logSpy.remove();
+    traceSpy.remove();
+  });
+  return {
+    restore: () => {
+      for (const restoreCallback of restoreCallbackSet) {
+        restoreCallback();
+      }
+      restoreCallbackSet.clear();
+    },
+  };
+};

package/src/function_side_effects/spy_filesystem_calls.js

@@ -0,0 +1,202 @@
+// https://github.com/antfu/fs-spy/blob/main/src/index.ts
+// https://github.com/tschaub/mock-fs/tree/main
+
+import { removeDirectorySync, removeFileSync } from "@jsenv/filesystem";
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { spyMethod } from "./spy_method.js";
+
+export const spyFilesystemCalls = (
+  {
+    writeFile = () => {},
+    writeDirectory = () => {},
+    removeFile = () => {},
+    // removeDirectory = () => {},
+  },
+  { undoFilesystemSideEffects } = {},
+) => {
+  const _internalFs = process.binding("fs");
+  const filesystemStateInfoMap = new Map();
+  const fileDescriptorPathMap = new Map();
+  const fileRestoreMap = new Map();
+  const onWriteFileDone = (fileUrl, stateBefore, stateAfter) => {
+    // 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 (
+      (!stateBefore.found && stateAfter.found) ||
+      stateBefore.content !== stateAfter.content ||
+      stateBefore.mtimeMs !== stateAfter.mtimeMs
+    ) {
+      if (undoFilesystemSideEffects && !fileRestoreMap.has(fileUrl)) {
+        if (stateBefore.found) {
+          fileRestoreMap.set(fileUrl, () => {
+            writeFileSync(fileUrl, stateBefore.content);
+          });
+        } else {
+          fileRestoreMap.set(fileUrl, () => {
+            removeFileSync(fileUrl, { allowUseless: true });
+          });
+        }
+      }
+      writeFile(fileUrl, stateAfter.content);
+      return;
+    }
+    // file is exactly the same
+    // function did not have any effect on the file
+  };
+  const onWriteDirectoryDone = (directoryUrl, stateBefore) => {
+    if (stateBefore.found) {
+      return;
+    }
+    if (undoFilesystemSideEffects && !fileRestoreMap.has(directoryUrl)) {
+      fileRestoreMap.set(directoryUrl, () => {
+        removeDirectorySync(directoryUrl, {
+          allowUseless: true,
+          recursive: true,
+        });
+      });
+    }
+    writeDirectory(directoryUrl);
+  };
+  const restoreCallbackSet = new Set();
+  const mkdirSpy = spyMethod(
+    _internalFs,
+    "mkdir",
+    (directoryPath, mode, recursive, callback) => {
+      const directoryUrl = pathToFileURL(directoryPath);
+      if (callback) {
+        const stateBefore = getDirectoryState(directoryPath);
+        const oncomplete = callback.oncomplete;
+        callback.oncomplete = (error, fd) => {
+          if (error) {
+            oncomplete(error);
+          } else {
+            fileDescriptorPathMap.set(fd, directoryPath);
+            oncomplete();
+            onWriteDirectoryDone(directoryUrl, stateBefore, { found: true });
+          }
+        };
+        return mkdirSpy.callOriginal();
+      }
+      const stateBefore = getDirectoryState(directoryPath);
+      mkdirSpy.callOriginal();
+      onWriteDirectoryDone(directoryUrl, stateBefore, { found: true });
+      return undefined;
+    },
+  );
+  const openSpy = spyMethod(
+    _internalFs,
+    "open",
+    (filePath, flags, mode, callback) => {
+      if (callback) {
+        const stateBefore = getFileState(filePath);
+        filesystemStateInfoMap.set(filePath, stateBefore);
+        const oncomplete = callback.oncomplete;
+        callback.oncomplete = (error, fd) => {
+          if (error) {
+            oncomplete(error);
+          } else {
+            fileDescriptorPathMap.set(fd, filePath);
+            oncomplete(error, fd);
+          }
+        };
+        return openSpy.callOriginal();
+      }
+      const stateBefore = getFileState(filePath);
+      filesystemStateInfoMap.set(filePath, stateBefore);
+      const fd = openSpy.callOriginal();
+      fileDescriptorPathMap.set(fd, filePath);
+      return fd;
+    },
+  );
+  const closeSpy = spyMethod(_internalFs, "close", (fileDescriptor) => {
+    const filePath = fileDescriptorPathMap.get(fileDescriptor);
+    if (!filePath) {
+      return closeSpy.callOriginal();
+    }
+    const openInfo = filesystemStateInfoMap.get(filePath);
+    if (!openInfo) {
+      const returnValue = closeSpy.callOriginal();
+      fileDescriptorPathMap.delete(fileDescriptor);
+      return returnValue;
+    }
+    const fileUrl = pathToFileURL(filePath);
+    const nowState = getFileState(fileUrl);
+    onWriteFileDone(fileUrl, openInfo, nowState);
+    const returnValue = closeSpy.callOriginal();
+    fileDescriptorPathMap.delete(fileDescriptor);
+    filesystemStateInfoMap.delete(filePath);
+    return returnValue;
+  });
+  const writeFileUtf8Spy = spyMethod(
+    _internalFs,
+    "writeFileUtf8",
+    (filePath) => {
+      const fileUrl = pathToFileURL(filePath);
+      const stateBefore = getFileState(fileUrl);
+      writeFileUtf8Spy.callOriginal();
+      const stateAfter = getFileState(fileUrl);
+      onWriteFileDone(fileUrl, stateBefore, stateAfter);
+    },
+  );
+  const unlinkSpy = spyMethod(_internalFs, "unlink", (filePath) => {
+    unlinkSpy.callOriginal();
+    removeFile(filePath); // TODO eventually split in removeFile/removeDirectory
+  });
+  restoreCallbackSet.add(() => {
+    mkdirSpy.remove();
+    openSpy.remove();
+    closeSpy.remove();
+    writeFileUtf8Spy.remove();
+    unlinkSpy.remove();
+  });
+  return {
+    restore: () => {
+      for (const restoreCallback of restoreCallbackSet) {
+        restoreCallback();
+      }
+      restoreCallbackSet.clear();
+      for (const [, restore] of fileRestoreMap) {
+        restore();
+      }
+      fileRestoreMap.clear();
+    },
+  };
+};
+
+const getFileState = (file) => {
+  try {
+    const fileContent = readFileSync(file);
+    const { mtimeMs } = statSync(file);
+    return {
+      found: true,
+      mtimeMs,
+      content: String(fileContent),
+    };
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return {
+        found: false,
+      };
+    }
+    throw e;
+  }
+};
+
+const getDirectoryState = (directory) => {
+  try {
+    statSync(directory);
+    return {
+      found: true,
+    };
+  } catch (e) {
+    if (e.code === "ENOENT") {
+      return {
+        found: false,
+      };
+    }
+    throw e;
+  }
+};

package/src/function_side_effects/spy_method.js

@@ -0,0 +1,111 @@
+const jsenvSpySymbol = Symbol.for("jsenv_spy");
+
+export const spyMethod = (object, method, spyCallback) => {
+  const current = object[method];
+  const jsenvSpySymbolValue = current[jsenvSpySymbol];
+  let addCallback;
+  let removeCallback;
+  let callOriginal;
+  let onOriginalCall;
+  let preventOriginalCall;
+  if (jsenvSpySymbolValue) {
+    addCallback = jsenvSpySymbolValue.addCallback;
+    removeCallback = jsenvSpySymbolValue.removeCallback;
+    callOriginal = jsenvSpySymbolValue.callOriginal;
+    onOriginalCall = jsenvSpySymbolValue.onOriginalCall;
+    preventOriginalCall = jsenvSpySymbolValue.preventOriginalCall;
+  } else {
+    const original = current;
+    let currentArgs;
+    let originalCalled = false;
+    let originalReturnValue;
+    let preventOriginalCallCalled;
+    let spyExecuting;
+    let someSpyUsedCallOriginal;
+    let allSpyUsedPreventOriginalCall;
+    onOriginalCall = (returnValue) => {
+      originalCalled = true;
+      originalReturnValue = returnValue;
+    };
+    callOriginal = () => {
+      if (someSpyUsedCallOriginal) {
+        return originalReturnValue;
+      }
+      someSpyUsedCallOriginal = true;
+      onOriginalCall(original(...currentArgs));
+      return originalReturnValue;
+    };
+    preventOriginalCall = () => {
+      preventOriginalCallCalled = true;
+    };
+    const spyCallbackSet = new Set();
+    const spy = (...args) => {
+      if (spyExecuting) {
+        // when a spy is executing
+        // if it calls the method himself
+        // then we want this call to go trough
+        // and others spy should not know about it
+        onOriginalCall(original(...args));
+        return originalReturnValue;
+      }
+      spyExecuting = true;
+      originalCalled = false;
+      currentArgs = args;
+      someSpyUsedCallOriginal = false;
+      allSpyUsedPreventOriginalCall = true;
+      for (const spyCallback of spyCallbackSet) {
+        try {
+          spyCallback(...args);
+        } finally {
+          if (preventOriginalCallCalled) {
+            preventOriginalCallCalled = false;
+          } else {
+            allSpyUsedPreventOriginalCall = false;
+          }
+        }
+      }
+      spyExecuting = false;
+      if (!someSpyUsedCallOriginal && !allSpyUsedPreventOriginalCall) {
+        callOriginal();
+      }
+      currentArgs = null;
+      if (originalCalled) {
+        originalCalled = false;
+        const value = originalReturnValue;
+        originalReturnValue = undefined;
+        return value;
+      }
+      return undefined;
+    };
+    addCallback = (spyCallback) => {
+      if (spyCallbackSet.size === 0) {
+        object[method] = spy;
+      }
+      spyCallbackSet.add(spyCallback);
+    };
+    removeCallback = (spyCallback) => {
+      spyCallbackSet.delete(spyCallback);
+      if (spyCallbackSet.size === 0) {
+        object[method] = original;
+      }
+    };
+    spy[jsenvSpySymbol] = {
+      addCallback,
+      removeCallback,
+      original,
+      callOriginal,
+      onOriginalCall,
+      preventOriginalCall,
+    };
+    object[method] = spy;
+  }
+  addCallback(spyCallback);
+  const spyHooks = {
+    callOriginal,
+    preventOriginalCall,
+    remove: () => {
+      removeCallback(spyCallback);
+    },
+  };
+  return spyHooks;
+};

package/src/main.js

@@ -2,5 +2,5 @@ export {
   takeDirectorySnapshot,
   takeFileSnapshot,
 } from "./filesystem_snapshot.js";
-export { snapshotFunctionSideEffects } from "./function_snapshot.js";
+export { snapshotFunctionSideEffects } from "./function_side_effects/function_side_effects_snapshot.js";
 export { replaceFluctuatingValues } from "./replace_fluctuating_values.js";

package/src/function_snapshot.js

@@ -1,256 +0,0 @@
-import {
-  readEntryStatSync,
-  readFileSync,
-  removeFileSync,
-  writeFileSync,
-} from "@jsenv/filesystem";
-import {
-  ensurePathnameTrailingSlash,
-  urlToFilename,
-  urlToRelativeUrl,
-} from "@jsenv/urls";
-import { takeDirectorySnapshot } from "./filesystem_snapshot.js";
-import { replaceFluctuatingValues } from "./replace_fluctuating_values.js";
-
-const consoleSpySymbol = Symbol.for("console_spy_for_jsenv_snapshot");
-
-export const snapshotFunctionSideEffects = (
-  fn,
-  fnFileUrl,
-  sideEffectDirectoryRelativeUrl = "./",
-  {
-    rootDirectoryUrl = new URL("./", fnFileUrl),
-    captureConsole = true,
-    filesystemEffects,
-    filesystemEffectsDirectory,
-    restoreFilesystem = true,
-  } = {},
-) => {
-  if (filesystemEffectsDirectory === true) {
-    filesystemEffectsDirectory = "./fs/";
-  }
-  const sideEffectDirectoryUrl = new URL(
-    sideEffectDirectoryRelativeUrl,
-    fnFileUrl,
-  );
-  const sideEffectDirectorySnapshot = takeDirectorySnapshot(
-    sideEffectDirectoryUrl,
-  );
-  const sideEffectFilename = `${urlToFilename(sideEffectDirectoryUrl)}_side_effects.txt`;
-  const sideEffectFileUrl = new URL(sideEffectFilename, sideEffectDirectoryUrl);
-  const sideEffects = [];
-  const finallyCallbackSet = new Set();
-  const onError = (e, isAsync) => {
-    sideEffects.push({
-      type: isAsync ? "reject" : "throw",
-      value: e,
-    });
-  };
-  const onResult = (result, isAsync) => {
-    sideEffects.push({
-      type: isAsync ? "resolve" : "return",
-      value: result,
-    });
-  };
-  const onFinally = () => {
-    for (const finallyCallback of finallyCallbackSet) {
-      finallyCallback();
-    }
-    writeFileSync(
-      sideEffectFileUrl,
-      stringifySideEffects(sideEffects, {
-        rootDirectoryUrl,
-        filesystemEffectsDirectory,
-      }),
-    );
-    sideEffectDirectorySnapshot.compare();
-  };
-  if (captureConsole) {
-    const installConsoleSpy = (methodName) => {
-      const methodSpied = console[methodName];
-      if (consoleSpySymbol in methodSpied) {
-        throw new Error("snapshotFunctionSideEffects already running");
-      }
-      const methodSpy = (message) => {
-        sideEffects.push({
-          type: `console.${methodName}`,
-          value: message,
-        });
-      };
-      methodSpy[consoleSpySymbol] = true;
-      console[methodName] = methodSpy;
-      finallyCallbackSet.add(() => {
-        console[methodName] = methodSpied;
-      });
-    };
-    installConsoleSpy("error");
-    installConsoleSpy("warn");
-    installConsoleSpy("info");
-    installConsoleSpy("log");
-  }
-  if (filesystemEffects) {
-    const fsSideEffectDirectoryUrl = ensurePathnameTrailingSlash(
-      new URL(filesystemEffectsDirectory, sideEffectDirectoryUrl),
-    );
-    const fsSideEffectsDirectoryRelativeUrl = urlToRelativeUrl(
-      fsSideEffectDirectoryUrl,
-      sideEffectFileUrl,
-    );
-    for (const filesystemEffect of filesystemEffects) {
-      const from = new URL(filesystemEffect, fnFileUrl);
-      const relativeUrl = urlToRelativeUrl(from, fnFileUrl);
-      const toUrl = new URL(relativeUrl, fsSideEffectDirectoryUrl);
-      const atStartState = getFileState(from);
-      const onFileSystemSideEffect = (fsSideEffect) => {
-        const last = sideEffects.pop();
-        sideEffects.push(fsSideEffect);
-        sideEffects.push(last);
-      };
-      finallyCallbackSet.add(() => {
-        const nowState = getFileState(from);
-        if (atStartState.found && !nowState.found) {
-          onFileSystemSideEffect({
-            type: `remove file "${relativeUrl}"`,
-            value: atStartState.content,
-          });
-          if (restoreFilesystem) {
-            writeFileSync(from, 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
-        ) {
-          if (filesystemEffectsDirectory) {
-            writeFileSync(toUrl, nowState.content);
-            onFileSystemSideEffect({
-              type: `write file "${relativeUrl}" (see ./${fsSideEffectsDirectoryRelativeUrl}${relativeUrl})`,
-              value: nowState.content,
-            });
-          } else {
-            onFileSystemSideEffect({
-              type: `write file "${relativeUrl}"`,
-              value: nowState.content,
-            });
-          }
-          if (restoreFilesystem) {
-            if (atStartState.found) {
-              if (atStartState.content !== nowState.content) {
-                writeFileSync(from, atStartState.content);
-              }
-            } else {
-              removeFileSync(from);
-            }
-          }
-          return;
-        }
-        // file is exactly the same
-        // function did not have any effect on the file
-      });
-    }
-  }
-  let returnedPromise = false;
-  try {
-    const returnValue = fn();
-    if (returnValue && returnValue.then) {
-      returnedPromise = returnValue.then(
-        (value) => {
-          onResult(value, true);
-          onFinally();
-        },
-        (e) => {
-          onError(e, true);
-          onFinally();
-        },
-      );
-      return returnedPromise;
-    }
-    onResult(returnValue);
-    return null;
-  } catch (e) {
-    onError(e);
-    return null;
-  } finally {
-    if (returnedPromise) {
-      return returnedPromise;
-    }
-    onFinally();
-  }
-};
-
-const stringifySideEffects = (
-  sideEffects,
-  { rootDirectoryUrl, filesystemEffectsDirectory },
-) => {
-  let string = "";
-  let index = 0;
-  for (const sideEffect of sideEffects) {
-    if (string) {
-      string += "\n\n";
-    }
-    string += `${index + 1}. ${sideEffect.type}`;
-    let value = sideEffect.value;
-    if (sideEffect.type.startsWith("console.")) {
-      value = replaceFluctuatingValues(value, {
-        stringType: "console",
-        rootDirectoryUrl,
-      });
-      string += "\n";
-      string += value;
-    } else if (
-      sideEffect.type.startsWith("remove file") ||
-      sideEffect.type.startsWith("write file")
-    ) {
-      if (!filesystemEffectsDirectory) {
-        string += "\n";
-        string += value;
-      }
-    } else if (sideEffect.type === "throw" || sideEffect.type === "reject") {
-      value = replaceFluctuatingValues(value.stack, {
-        stringType: "error",
-      });
-      string += "\n";
-      string += value;
-    } else if (sideEffect.type === "return" || sideEffect.type === "resolve") {
-      value =
-        value === undefined
-          ? undefined
-          : replaceFluctuatingValues(JSON.stringify(value, null, "  "), {
-              stringType: "json",
-              rootDirectoryUrl,
-            });
-      string += "\n";
-      string += value;
-    } else {
-      string += "\n";
-      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;
-  }
-};