@jsenv/snapshot 2.3.3 → 2.4.1

package/package.json

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

package/src/function_side_effects/function_side_effects_snapshot.js

@@ -15,19 +15,29 @@ import {
 import { spyConsoleCalls } from "./spy_console_calls.js";
 import { spyFilesystemCalls } from "./spy_filesystem_calls.js";
 
+const filesystemEffectsDefault = {
+  outDirectory: null,
+  preserve: false,
+};
+const consoleEffectsDefault = {
+  prevent: true,
+};
+
 export const snapshotFunctionSideEffects = (
   fn,
   fnFileUrl,
   sideEffectDirectoryRelativeUrl = "./",
   {
     rootDirectoryUrl = new URL("./", fnFileUrl),
-    filesystemEffectsDirectory,
-    preventConsoleSideEffects = true,
-    undoFilesystemSideEffects = true,
+    consoleEffects = true,
+    filesystemEffects = true,
   } = {},
 ) => {
-  if (filesystemEffectsDirectory === true) {
-    filesystemEffectsDirectory = "./fs/";
+  if (consoleEffects === true) {
+    consoleEffects = {};
+  }
+  if (filesystemEffects === true) {
+    filesystemEffects = {};
   }
   const sideEffectDirectoryUrl = new URL(
     sideEffectDirectoryRelativeUrl,
@@ -40,103 +50,123 @@ export const snapshotFunctionSideEffects = (
   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: wrapIntoMarkdownBlock(
-              replaceFluctuatingValues(message, {
-                stringType: "console",
-                rootDirectoryUrl,
-              }),
-              "console",
-            ),
-          });
-        };
-        const consoleSpy = spyConsoleCalls(
+    ...(consoleEffects
+      ? [
           {
-            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) => {
-        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 {
+            name: "console",
+            install: (addSideEffect) => {
+              consoleEffects = { ...consoleEffectsDefault, ...consoleEffects };
+              const { prevent } = consoleEffects;
+              const onConsole = (methodName, message) => {
                 addSideEffect({
-                  type: "fs:write_file",
-                  value: { relativeUrl, content },
-                  label: `write file "${relativeUrl}"`,
+                  type: `console:${methodName}`,
+                  value: message,
+                  label: `console.${methodName}`,
                   text: wrapIntoMarkdownBlock(
-                    content,
-                    urlToExtension(url).slice(1),
+                    replaceFluctuatingValues(message, {
+                      stringType: "console",
+                      rootDirectoryUrl,
+                    }),
+                    "console",
                   ),
                 });
-              }
-            },
-            writeDirectory: (url) => {
-              const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
-              addSideEffect({
-                type: "fs:write_directory",
-                value: { relativeUrl },
-                label: `write directory "${relativeUrl}"`,
-                text: null,
-              });
+              };
+              const consoleSpy = spyConsoleCalls(
+                {
+                  error: (message) => {
+                    onConsole("error", message);
+                  },
+                  warn: (message) => {
+                    onConsole("warn", message);
+                  },
+                  info: (message) => {
+                    onConsole("info", message);
+                  },
+                  log: (message) => {
+                    onConsole("log", message);
+                  },
+                },
+                {
+                  preventConsoleSideEffects: prevent,
+                },
+              );
+              return () => {
+                consoleSpy.restore();
+              };
             },
           },
+        ]
+      : []),
+    ...(filesystemEffects
+      ? [
           {
-            undoFilesystemSideEffects,
+            name: "filesystem",
+            install: (addSideEffect) => {
+              filesystemEffects = {
+                ...filesystemEffectsDefault,
+                ...filesystemEffects,
+              };
+              let writeFile;
+              const { preserve, outDirectory } = filesystemEffects;
+              if (outDirectory) {
+                const fsEffectsOutDirectoryUrl = ensurePathnameTrailingSlash(
+                  new URL(outDirectory, sideEffectDirectoryUrl),
+                );
+                const fsEffectsOutDirectoryRelativeUrl = urlToRelativeUrl(
+                  fsEffectsOutDirectoryUrl,
+                  sideEffectFileUrl,
+                );
+                writeFile = (url, content) => {
+                  const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
+                  const toUrl = new URL(relativeUrl, fsEffectsOutDirectoryUrl);
+                  callbackSet.add(() => {
+                    writeFileSync(toUrl, content);
+                  });
+                  addSideEffect({
+                    type: "fs:write_file",
+                    value: { relativeUrl, content },
+                    label: `write file "${relativeUrl}" (see ./${fsEffectsOutDirectoryRelativeUrl}${relativeUrl})`,
+                    text: null,
+                  });
+                };
+              } else {
+                writeFile = (url, content) => {
+                  const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
+                  addSideEffect({
+                    type: "fs:write_file",
+                    value: { relativeUrl, content },
+                    label: `write file "${relativeUrl}"`,
+                    text: wrapIntoMarkdownBlock(
+                      content,
+                      urlToExtension(url).slice(1),
+                    ),
+                  });
+                };
+              }
+              const filesystemSpy = spyFilesystemCalls(
+                {
+                  writeFile,
+                  writeDirectory: (url) => {
+                    const relativeUrl = urlToRelativeUrl(url, fnFileUrl);
+                    addSideEffect({
+                      type: "fs:write_directory",
+                      value: { relativeUrl },
+                      label: `write directory "${relativeUrl}"`,
+                      text: null,
+                    });
+                  },
+                },
+                {
+                  undoFilesystemSideEffects: !preserve,
+                },
+              );
+              return () => {
+                filesystemSpy.restore();
+              };
+            },
           },
-        );
-        return () => {
-          filesystemSpy.restore();
-        };
-      },
-    },
+        ]
+      : []),
   ];
 
   const onSideEffectsCollected = (sideEffects) => {

package/src/function_side_effects/spy_filesystem_calls.js

@@ -1,16 +1,19 @@
 // https://github.com/antfu/fs-spy/blob/main/src/index.ts
 // https://github.com/tschaub/mock-fs/tree/main
+// https://github.com/tschaub/mock-fs/blob/6e84d5bb320022624c7d770432e3322323ce043e/lib/binding.js#L353
+// https://github.com/tschaub/mock-fs/issues/348
 
 import { removeDirectorySync, removeFileSync } from "@jsenv/filesystem";
 import { readFileSync, statSync, writeFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { spyMethod } from "./spy_method.js";
+import { disableSpiesWhileCalling, spyMethod } from "./spy_method.js";
 
 export const spyFilesystemCalls = (
   {
+    readFile = () => {}, // TODO
     writeFile = () => {},
     writeDirectory = () => {},
-    removeFile = () => {},
+    removeFile = () => {}, // TODO
     // removeDirectory = () => {},
   },
   { undoFilesystemSideEffects } = {},
@@ -61,6 +64,14 @@ export const spyFilesystemCalls = (
     writeDirectory(directoryUrl);
   };
   const restoreCallbackSet = new Set();
+
+  const getFileStateWithinSpy = (fileUrl) => {
+    return disableSpiesWhileCalling(
+      () => getFileState(fileUrl),
+      [openSpy, closeSpy],
+    );
+  };
+
   const mkdirSpy = spyMethod(
     _internalFs,
     "mkdir",
@@ -90,54 +101,118 @@ export const spyFilesystemCalls = (
     _internalFs,
     "open",
     (filePath, flags, mode, callback) => {
+      const stateBefore = getFileStateWithinSpy(filePath);
+      filesystemStateInfoMap.set(filePath, stateBefore);
       if (callback) {
-        const stateBefore = getFileState(filePath);
-        filesystemStateInfoMap.set(filePath, stateBefore);
-        const oncomplete = callback.oncomplete;
-        callback.oncomplete = (error, fd) => {
+        if (callback.context) {
+          const original = callback.context.callback;
+          callback.context.callback = function (...args) {
+            callback.context.callback = original;
+            const [error, fd] = args;
+            if (error) {
+              original.call(this, ...args);
+            } else {
+              if (typeof fd === "number") {
+                fileDescriptorPathMap.set(fd, filePath);
+              } else {
+                // it's a buffer (happens for readFile)
+              }
+              original.call(this, ...args);
+            }
+          };
+          openSpy.callOriginal();
+          return;
+        }
+        const original = callback.oncomplete;
+        callback.oncomplete = function (...args) {
+          callback.oncomplete = original;
+          const [error, fd] = args;
           if (error) {
-            oncomplete.call(callback, error);
+            original.call(this, ...args);
           } else {
             fileDescriptorPathMap.set(fd, filePath);
-            oncomplete.call(callback, error, fd);
+            original.call(this, ...args);
           }
         };
-        return openSpy.callOriginal();
+        openSpy.callOriginal();
+        return;
       }
-      const stateBefore = getFileState(filePath);
-      filesystemStateInfoMap.set(filePath, stateBefore);
       const fd = openSpy.callOriginal();
-      fileDescriptorPathMap.set(fd, filePath);
-      return fd;
+      if (typeof fd === "number") {
+        fileDescriptorPathMap.set(fd, filePath);
+      } else {
+        // it's a buffer (happens for readFile)
+      }
     },
   );
-  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();
+  const closeSpy = spyMethod(
+    _internalFs,
+    "close",
+    (fileDescriptor, callback) => {
+      const filePath = fileDescriptorPathMap.get(fileDescriptor);
+      if (!filePath) {
+        closeSpy.callOriginal();
+        return;
+      }
+      const stateBefore = filesystemStateInfoMap.get(filePath);
+      if (!stateBefore) {
+        closeSpy.callOriginal();
+        fileDescriptorPathMap.delete(fileDescriptor);
+        return;
+      }
+      const fileUrl = pathToFileURL(filePath);
+      if (callback) {
+        if (callback.context) {
+          const original = callback.context.callback;
+          callback.context.callback = function (...args) {
+            callback.context.callback = original;
+            const [error] = args;
+            if (error) {
+              original.call(this, ...args);
+            } else {
+              original.call(this, ...args);
+              fileDescriptorPathMap.delete(fileDescriptor);
+              filesystemStateInfoMap.delete(filePath);
+              const stateAfter = getFileStateWithinSpy(fileUrl);
+              readFile(fileUrl);
+              onWriteFileDone(fileUrl, stateBefore, stateAfter);
+            }
+          };
+          closeSpy.callOriginal();
+          return;
+        }
+        const original = callback.oncomplete;
+        callback.oncomplete = function (...args) {
+          callback.oncomplete = original;
+          const [error] = args;
+          if (error) {
+            original.call(this, ...args);
+          } else {
+            original.call(this, ...args);
+            fileDescriptorPathMap.delete(fileDescriptor);
+            filesystemStateInfoMap.delete(filePath);
+            const stateAfter = getFileStateWithinSpy(fileUrl);
+            onWriteFileDone(fileUrl, stateBefore, stateAfter);
+          }
+        };
+        closeSpy.callOriginal();
+        return;
+      }
+      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;
-  });
+      filesystemStateInfoMap.delete(filePath);
+      const stateAfter = getFileStateWithinSpy(fileUrl);
+      onWriteFileDone(fileUrl, stateBefore, stateAfter);
+    },
+  );
   const writeFileUtf8Spy = spyMethod(
     _internalFs,
     "writeFileUtf8",
     (filePath) => {
       const fileUrl = pathToFileURL(filePath);
-      const stateBefore = getFileState(fileUrl);
+      const stateBefore = getFileStateWithinSpy(fileUrl);
       writeFileUtf8Spy.callOriginal();
-      const stateAfter = getFileState(fileUrl);
+      const stateAfter = getFileStateWithinSpy(fileUrl);
       onWriteFileDone(fileUrl, stateBefore, stateAfter);
     },
   );

package/src/function_side_effects/spy_method.js

@@ -16,6 +16,7 @@ export const spyMethod = (object, method, spyCallback) => {
     preventOriginalCall = jsenvSpySymbolValue.preventOriginalCall;
   } else {
     const original = current;
+    let currentThis;
     let currentArgs;
     let originalCalled = false;
     let originalReturnValue;
@@ -32,33 +33,40 @@ export const spyMethod = (object, method, spyCallback) => {
         return originalReturnValue;
       }
       someSpyUsedCallOriginal = true;
-      onOriginalCall(original(...currentArgs));
+      onOriginalCall(original.call(currentThis, ...currentArgs));
       return originalReturnValue;
     };
     preventOriginalCall = () => {
       preventOriginalCallCalled = true;
     };
     const spyCallbackSet = new Set();
-    const spy = (...args) => {
+    const spy = function (...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));
+        onOriginalCall(original.call(this, ...args));
         return originalReturnValue;
       }
       spyExecuting = true;
       originalCalled = false;
+      currentThis = this;
       currentArgs = args;
       someSpyUsedCallOriginal = false;
-      allSpyUsedPreventOriginalCall = true;
+      allSpyUsedPreventOriginalCall = undefined;
       for (const spyCallback of spyCallbackSet) {
+        if (spyCallback.disabled) {
+          continue;
+        }
         try {
           spyCallback(...args);
         } finally {
           if (preventOriginalCallCalled) {
             preventOriginalCallCalled = false;
+            if (allSpyUsedPreventOriginalCall === undefined) {
+              allSpyUsedPreventOriginalCall = true;
+            }
           } else {
             allSpyUsedPreventOriginalCall = false;
           }
@@ -68,6 +76,7 @@ export const spyMethod = (object, method, spyCallback) => {
       if (!someSpyUsedCallOriginal && !allSpyUsedPreventOriginalCall) {
         callOriginal();
       }
+      currentThis = null;
       currentArgs = null;
       if (originalCalled) {
         originalCalled = false;
@@ -103,9 +112,28 @@ export const spyMethod = (object, method, spyCallback) => {
   const spyHooks = {
     callOriginal,
     preventOriginalCall,
+    disable: () => {
+      spyCallback.disabled = true;
+    },
+    enable: () => {
+      spyCallback.disabled = false;
+    },
     remove: () => {
       removeCallback(spyCallback);
     },
   };
   return spyHooks;
 };
+
+export const disableSpiesWhileCalling = (fn, spyToDisableArray) => {
+  for (const spyToDisable of spyToDisableArray) {
+    spyToDisable.disable();
+  }
+  try {
+    return fn();
+  } finally {
+    for (const spyToEnable of spyToDisableArray) {
+      spyToEnable.enable();
+    }
+  }
+};