@jsenv/snapshot 2.5.0 → 2.5.1

package/package.json

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

package/src/function_side_effects/hook_into_method.js

@@ -0,0 +1,261 @@
+const jsenvMethodProxySymbol = Symbol.for("jsenv_method_proxy");
+
+export const hookIntoMethod = (
+  object,
+  method,
+  initCallback,
+  { execute = METHOD_EXECUTION_STANDARD } = {},
+) => {
+  const current = object[method];
+  const jsenvSymbolValue = current[jsenvMethodProxySymbol];
+  let addInitCallback;
+  let removeInitCallback;
+  if (jsenvSymbolValue) {
+    addInitCallback = jsenvSymbolValue.addInitCallback;
+    removeInitCallback = jsenvSymbolValue.removeInitCallback;
+  } else {
+    const original = current;
+    let allWantsToPreventOriginalCall;
+    let hookExecuting;
+    const initCallbackSet = new Set();
+    const callHooks = (hookCallbackSet, ...args) => {
+      hookExecuting = true;
+      for (const hookCallback of hookCallbackSet) {
+        hookCallback(...args);
+      }
+      hookExecuting = false;
+      hookCallbackSet.clear();
+    };
+
+    const proxy = function (...args) {
+      if (hookExecuting) {
+        // 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
+        return original.call(this, ...args);
+      }
+      allWantsToPreventOriginalCall = undefined;
+      const returnPromiseCallbackSet = new Set();
+      const returnCallbackSet = new Set();
+      const catchCallbackSet = new Set();
+      const finallyCallbackSet = new Set();
+      hookExecuting = true;
+      for (const initCallback of initCallbackSet) {
+        if (initCallback.disabled) {
+          continue;
+        }
+        const hooks = initCallback(...args) || {};
+        if (hooks.preventOriginalCall) {
+          if (allWantsToPreventOriginalCall === undefined) {
+            allWantsToPreventOriginalCall = true;
+          }
+        } else {
+          allWantsToPreventOriginalCall = false;
+        }
+        if (hooks.returnPromise) {
+          returnPromiseCallbackSet.add(hooks.returnPromise);
+        }
+        if (hooks.return) {
+          returnCallbackSet.add(hooks.return);
+        }
+        if (hooks.catch) {
+          catchCallbackSet.add(hooks.catch);
+        }
+        if (hooks.finally) {
+          finallyCallbackSet.add(hooks.catch);
+        }
+      }
+      hookExecuting = false;
+      const onCatch = (valueThrown) => {
+        returnCallbackSet.clear();
+        callHooks(catchCallbackSet, valueThrown);
+      };
+      const onReturn = (...values) => {
+        returnPromiseCallbackSet.clear();
+        catchCallbackSet.clear();
+        callHooks(returnCallbackSet, ...values);
+      };
+      const onReturnPromise = () => {
+        callHooks(returnPromiseCallbackSet);
+      };
+      const onFinally = () => {
+        callHooks(finallyCallbackSet);
+      };
+      if (allWantsToPreventOriginalCall) {
+        onReturn(undefined);
+        onFinally();
+        return undefined;
+      }
+      return execute({
+        original,
+        thisValue: this,
+        args,
+        onCatch,
+        onReturn,
+        onReturnPromise,
+        onFinally,
+      });
+    };
+    addInitCallback = (initCallback) => {
+      if (initCallbackSet.size === 0) {
+        object[method] = proxy;
+      }
+      initCallbackSet.add(initCallback);
+    };
+    removeInitCallback = (initCallback) => {
+      initCallbackSet.delete(initCallback);
+      if (initCallbackSet.size === 0) {
+        object[method] = original;
+      }
+    };
+    proxy[jsenvMethodProxySymbol] = {
+      addInitCallback,
+      removeInitCallback,
+      original,
+    };
+    object[method] = proxy;
+  }
+  addInitCallback(initCallback);
+  const hook = {
+    disable: () => {
+      initCallback.disabled = true;
+    },
+    enable: () => {
+      initCallback.disabled = false;
+    },
+    remove: () => {
+      removeInitCallback(initCallback);
+    },
+  };
+  return hook;
+};
+export const METHOD_EXECUTION_STANDARD = ({
+  original,
+  thisValue,
+  args,
+  onCatch,
+  onFinally,
+  onReturnPromise,
+  onReturn,
+}) => {
+  let valueReturned;
+  let thrown = false;
+  let valueThrown;
+  try {
+    valueReturned = original.call(thisValue, ...args);
+  } catch (e) {
+    thrown = true;
+    valueThrown = e;
+  }
+  if (thrown) {
+    onCatch(valueThrown);
+    onFinally();
+    throw valueThrown;
+  }
+  if (valueReturned && typeof valueReturned.then === "function") {
+    onReturnPromise();
+    valueReturned.then(
+      (valueResolved) => {
+        onReturn(valueResolved);
+        onFinally();
+      },
+      (valueRejected) => {
+        onCatch(valueRejected);
+        onFinally();
+      },
+    );
+    return valueReturned;
+  }
+  onReturn(valueReturned);
+  onFinally();
+  return valueReturned;
+};
+export const METHOD_EXECUTION_NODE_CALLBACK = ({
+  original,
+  thisValue,
+  args,
+  onCatch,
+  onFinally,
+  onReturnPromise,
+  onReturn,
+}) => {
+  const lastArgIndex = args.length - 1;
+  const lastArg = args[lastArgIndex];
+  const installProxyAndCall = (originalCallback, installCallbackProxy) => {
+    const callbackProxy = function (...callbackArgs) {
+      uninstallCallbackProxy();
+      const [error, ...remainingArgs] = callbackArgs;
+      if (error) {
+        onCatch(error);
+        originalCallback.call(this, ...callbackArgs);
+        onFinally();
+        return;
+      }
+      onReturn(...remainingArgs);
+      originalCallback.call(this, ...callbackArgs);
+      onFinally();
+    };
+    const uninstallCallbackProxy = installCallbackProxy(callbackProxy);
+    try {
+      return original.call(thisValue, ...args);
+    } catch (e) {
+      onCatch(e);
+      onFinally();
+      throw e;
+    }
+  };
+  if (typeof lastArg === "function") {
+    return installProxyAndCall(lastArg, (callbackProxy) => {
+      args[lastArgIndex] = callbackProxy;
+      return () => {
+        // useless because are a copy of the args
+        // so the mutation we do above ( args[lastArgIndex] =)
+        // cannot be important for the method being proxied
+        args[lastArgIndex] = lastArg;
+      };
+    });
+  }
+  if (lastArg && typeof lastArg === "object") {
+    if (lastArg.context && typeof lastArg.context.callback === "function") {
+      const originalCallback = lastArg.context.callback;
+      return installProxyAndCall(originalCallback, (callbackProxy) => {
+        lastArg.context.callback = callbackProxy;
+        return () => {
+          lastArg.context.callback = originalCallback;
+        };
+      });
+    }
+    if (typeof lastArg.oncomplete === "function") {
+      const originalCallback = lastArg.oncomplete;
+      return installProxyAndCall(originalCallback, (callbackProxy) => {
+        lastArg.oncomplete = callbackProxy;
+        return () => {
+          lastArg.oncomplete = originalCallback;
+        };
+      });
+    }
+  }
+  return METHOD_EXECUTION_STANDARD({
+    original,
+    thisValue,
+    args,
+    onCatch,
+    onFinally,
+    onReturnPromise,
+    onReturn,
+  });
+};
+
+export const disableHooksWhileCalling = (fn, hookToDisableArray) => {
+  for (const toDisable of hookToDisableArray) {
+    toDisable.disable();
+  }
+  try {
+    return fn();
+  } finally {
+    for (const toEnable of hookToDisableArray) {
+      toEnable.enable();
+    }
+  }
+};

package/src/function_side_effects/spy_console_calls.js

@@ -1,46 +1,56 @@
-import { spyMethod } from "./spy_method.js";
+import { hookIntoMethod } from "./hook_into_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 errorHook = hookIntoMethod(console, "error", (message) => {
+    return {
+      preventOriginalCall: preventConsoleSideEffects,
+      return: () => {
+        error(message);
+      },
+    };
   });
-  const warnSpy = spyMethod(console, "warn", (message) => {
-    if (preventConsoleSideEffects) {
-      warnSpy.preventOriginalCall();
-    }
-    warn(message);
+  const warnHook = hookIntoMethod(console, "warn", (message) => {
+    return {
+      preventOriginalCall: preventConsoleSideEffects,
+      return: () => {
+        warn(message);
+      },
+    };
   });
-  const infoSpy = spyMethod(console, "info", (message) => {
-    if (preventConsoleSideEffects) {
-      infoSpy.preventOriginalCall();
-    }
-    info(message);
+  const infoHook = hookIntoMethod(console, "info", (message) => {
+    return {
+      preventOriginalCall: preventConsoleSideEffects,
+      return: () => {
+        info(message);
+      },
+    };
   });
-  const logSpy = spyMethod(console, "log", (message) => {
-    if (preventConsoleSideEffects) {
-      logSpy.preventOriginalCall();
-    }
-    log(message);
+  const logHook = hookIntoMethod(console, "log", (message) => {
+    return {
+      preventOriginalCall: preventConsoleSideEffects,
+      return: () => {
+        log(message);
+      },
+    };
   });
-  const traceSpy = spyMethod(console, "trace", (message) => {
-    if (preventConsoleSideEffects) {
-      traceSpy.preventOriginalCall();
-    }
-    trace(message);
+  const traceHook = hookIntoMethod(console, "trace", (message) => {
+    return {
+      preventOriginalCall: preventConsoleSideEffects,
+      return: () => {
+        trace(message);
+      },
+    };
   });
   restoreCallbackSet.add(() => {
-    errorSpy.remove();
-    warnSpy.remove();
-    infoSpy.remove();
-    logSpy.remove();
-    traceSpy.remove();
+    errorHook.remove();
+    warnHook.remove();
+    infoHook.remove();
+    logHook.remove();
+    traceHook.remove();
   });
   return {
     restore: () => {

package/src/function_side_effects/spy_filesystem_calls.js

@@ -6,7 +6,11 @@
 import { removeDirectorySync, removeFileSync } from "@jsenv/filesystem";
 import { readFileSync, statSync, writeFileSync } from "node:fs";
 import { pathToFileURL } from "node:url";
-import { disableSpiesWhileCalling, spyMethod } from "./spy_method.js";
+import {
+  disableHooksWhileCalling,
+  hookIntoMethod,
+  METHOD_EXECUTION_NODE_CALLBACK,
+} from "./hook_into_method.js";
 
 export const spyFilesystemCalls = (
   {
@@ -65,167 +69,101 @@ export const spyFilesystemCalls = (
   };
   const restoreCallbackSet = new Set();
 
-  const getFileStateWithinSpy = (fileUrl) => {
-    return disableSpiesWhileCalling(
+  const getFileStateWithinHook = (fileUrl) => {
+    return disableHooksWhileCalling(
       () => getFileState(fileUrl),
-      [openSpy, closeSpy],
+      [openHook, closeHook],
     );
   };
 
-  const mkdirSpy = spyMethod(
+  const mkdirHook = hookIntoMethod(
     _internalFs,
     "mkdir",
-    (directoryPath, mode, recursive, callback) => {
+    (directoryPath) => {
       const directoryUrl = pathToFileURL(directoryPath);
-      if (callback) {
-        const stateBefore = getDirectoryState(directoryPath);
-        const oncomplete = callback.oncomplete;
-        callback.oncomplete = (error, fd) => {
-          if (error) {
-            oncomplete.call(callback, error);
-          } else {
-            fileDescriptorPathMap.set(fd, directoryPath);
-            oncomplete.call(callback);
-            onWriteDirectoryDone(directoryUrl, stateBefore, { found: true });
-          }
-        };
-        return mkdirSpy.callOriginal();
-      }
       const stateBefore = getDirectoryState(directoryPath);
-      mkdirSpy.callOriginal();
-      onWriteDirectoryDone(directoryUrl, stateBefore, { found: true });
-      return undefined;
+      return {
+        return: (fd) => {
+          fileDescriptorPathMap.set(fd, directoryPath);
+          onWriteDirectoryDone(directoryUrl, stateBefore, { found: true });
+        },
+      };
     },
+    { execute: METHOD_EXECUTION_NODE_CALLBACK },
   );
-  const openSpy = spyMethod(
+  const openHook = hookIntoMethod(
     _internalFs,
     "open",
-    (filePath, flags, mode, callback) => {
-      const stateBefore = getFileStateWithinSpy(filePath);
+    (filePath) => {
+      const stateBefore = getFileStateWithinHook(filePath);
       filesystemStateInfoMap.set(filePath, stateBefore);
-      if (callback) {
-        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) {
-            original.call(this, ...args);
-          } else {
+      return {
+        return: (fd) => {
+          if (typeof fd === "number") {
             fileDescriptorPathMap.set(fd, filePath);
-            original.call(this, ...args);
+          } else {
+            // it's a buffer (happens for readFile)
           }
-        };
-        openSpy.callOriginal();
-        return;
-      }
-      const fd = openSpy.callOriginal();
-      if (typeof fd === "number") {
-        fileDescriptorPathMap.set(fd, filePath);
-      } else {
-        // it's a buffer (happens for readFile)
-      }
+        },
+      };
     },
+    { execute: METHOD_EXECUTION_NODE_CALLBACK },
   );
-  const closeSpy = spyMethod(
+  const closeHook = hookIntoMethod(
     _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);
+    (fileDescriptor) => {
+      return {
+        return: (buffer) => {
+          const filePath = fileDescriptorPathMap.get(fileDescriptor);
+          if (!filePath) {
+            return;
+          }
+          const stateBefore = filesystemStateInfoMap.get(filePath);
+          if (!stateBefore) {
             fileDescriptorPathMap.delete(fileDescriptor);
-            filesystemStateInfoMap.delete(filePath);
-            const stateAfter = getFileStateWithinSpy(fileUrl);
-            onWriteFileDone(fileUrl, stateBefore, stateAfter);
+            return;
           }
-        };
-        closeSpy.callOriginal();
-        return;
-      }
-      closeSpy.callOriginal();
-      fileDescriptorPathMap.delete(fileDescriptor);
-      filesystemStateInfoMap.delete(filePath);
-      const stateAfter = getFileStateWithinSpy(fileUrl);
-      onWriteFileDone(fileUrl, stateBefore, stateAfter);
+          const fileUrl = pathToFileURL(filePath);
+          if (buffer) {
+            readFile(fileUrl);
+          }
+          fileDescriptorPathMap.delete(fileDescriptor);
+          filesystemStateInfoMap.delete(filePath);
+          const stateAfter = getFileStateWithinHook(fileUrl);
+          onWriteFileDone(fileUrl, stateBefore, stateAfter);
+        },
+      };
     },
+    { execute: METHOD_EXECUTION_NODE_CALLBACK },
   );
-  const writeFileUtf8Spy = spyMethod(
+  const writeFileUtf8Hook = hookIntoMethod(
     _internalFs,
     "writeFileUtf8",
     (filePath) => {
       const fileUrl = pathToFileURL(filePath);
-      const stateBefore = getFileStateWithinSpy(fileUrl);
-      writeFileUtf8Spy.callOriginal();
-      const stateAfter = getFileStateWithinSpy(fileUrl);
-      onWriteFileDone(fileUrl, stateBefore, stateAfter);
+      const stateBefore = getFileStateWithinHook(fileUrl);
+      return {
+        return: () => {
+          const stateAfter = getFileStateWithinHook(fileUrl);
+          onWriteFileDone(fileUrl, stateBefore, stateAfter);
+        },
+      };
     },
   );
-  const unlinkSpy = spyMethod(_internalFs, "unlink", (filePath) => {
-    unlinkSpy.callOriginal();
-    removeFile(filePath); // TODO eventually split in removeFile/removeDirectory
+  const unlinkHook = hookIntoMethod(_internalFs, "unlink", (filePath) => {
+    return {
+      return: () => {
+        removeFile(filePath); // TODO eventually split in removeFile/removeDirectory
+      },
+    };
   });
   restoreCallbackSet.add(() => {
-    mkdirSpy.remove();
-    openSpy.remove();
-    closeSpy.remove();
-    writeFileUtf8Spy.remove();
-    unlinkSpy.remove();
+    mkdirHook.remove();
+    openHook.remove();
+    closeHook.remove();
+    writeFileUtf8Hook.remove();
+    unlinkHook.remove();
   });
   return {
     restore: () => {

package/src/function_side_effects/spy_method.js

@@ -1,139 +0,0 @@
-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 currentThis;
-    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.call(currentThis, ...currentArgs));
-      return originalReturnValue;
-    };
-    preventOriginalCall = () => {
-      preventOriginalCallCalled = true;
-    };
-    const spyCallbackSet = new Set();
-    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.call(this, ...args));
-        return originalReturnValue;
-      }
-      spyExecuting = true;
-      originalCalled = false;
-      currentThis = this;
-      currentArgs = args;
-      someSpyUsedCallOriginal = false;
-      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;
-          }
-        }
-      }
-      spyExecuting = false;
-      if (!someSpyUsedCallOriginal && !allSpyUsedPreventOriginalCall) {
-        callOriginal();
-      }
-      currentThis = null;
-      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,
-    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();
-    }
-  }
-};