@jsenv/snapshot 2.4.0 → 2.4.2

package/package.json

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

package/src/function_side_effects/function_side_effects_snapshot.js

@@ -28,6 +28,7 @@ export const snapshotFunctionSideEffects = (
   fnFileUrl,
   sideEffectDirectoryRelativeUrl = "./",
   {
+    sideEffectbasename,
     rootDirectoryUrl = new URL("./", fnFileUrl),
     consoleEffects = true,
     filesystemEffects = true,
@@ -46,7 +47,10 @@ export const snapshotFunctionSideEffects = (
   const sideEffectDirectorySnapshot = takeDirectorySnapshot(
     sideEffectDirectoryUrl,
   );
-  const sideEffectFilename = `${urlToFilename(sideEffectDirectoryUrl)}_side_effects.md`;
+  if (sideEffectbasename === undefined) {
+    sideEffectbasename = `${urlToFilename(sideEffectDirectoryUrl)}_side_effects`;
+  }
+  const sideEffectFilename = `${sideEffectbasename}.md`;
   const sideEffectFileUrl = new URL(sideEffectFilename, sideEffectDirectoryUrl);
   const callbackSet = new Set();
   const sideEffectDetectors = [

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();
+    }
+  }
+};