@jsenv/snapshot 2.10.2 → 2.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.10.2",
+  "version": "2.10.3",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -34,7 +34,7 @@
   },
   "dependencies": {
     "@jsenv/assert": "4.4.1",
-    "@jsenv/ast": "6.2.16",
+    "@jsenv/ast": "6.2.17",
     "@jsenv/exception": "1.1.2",
     "@jsenv/humanize": "1.2.8",
     "@jsenv/filesystem": "4.10.2",

package/src/side_effects/create_capture_side_effects.js

@@ -15,6 +15,13 @@ export const createCaptureSideEffects = ({
     rootDirectoryUrl,
   }),
 }) => {
+  if (executionEffects === false) {
+    executionEffects = {
+      catch: false,
+      return: false,
+    };
+  }
+
   const detectors = [];
   if (logEffects) {
     detectors.push(logSideEffects(logEffects === true ? {} : logEffects));
@@ -283,6 +290,33 @@ export const createCaptureSideEffects = ({
       finallyCallbackSet.clear();
     };
 
+    const onThrowOrReject = (value, isThrow) => {
+      if (executionEffects.catch === false) {
+        throw value;
+      }
+      if (typeof executionEffects.catch === "function") {
+        executionEffects.catch(value);
+      }
+      if (isThrow) {
+        onCatch(value);
+      } else {
+        onReject(value);
+      }
+    };
+    const onReturnOrResolve = (value, isReturn) => {
+      if (executionEffects.return === false) {
+        return;
+      }
+      if (typeof executionEffects.return === "function") {
+        executionEffects.return(value);
+      }
+      if (isReturn) {
+        onReturn(value);
+      } else {
+        onResolve(value);
+      }
+    };
+
     process.env.CAPTURING_SIDE_EFFECTS = "1";
     functionExecutingCount++;
     let returnedPromise = false;
@@ -292,34 +326,22 @@ export const createCaptureSideEffects = ({
         onReturn(RETURN_PROMISE);
         returnedPromise = valueReturned.then(
           (value) => {
-            onResolve(value);
+            onReturnOrResolve(value);
             onFinally();
             return sideEffects;
           },
           (e) => {
-            if (executionEffects.catch === false) {
-              throw e;
-            }
-            if (typeof executionEffects.catch === "function") {
-              executionEffects.catch(e);
-            }
-            onReject(e);
+            onThrowOrReject(e);
             onFinally();
             return sideEffects;
           },
         );
         return returnedPromise;
       }
-      onReturn(valueReturned);
+      onReturnOrResolve(valueReturned, true);
       return sideEffects;
     } catch (e) {
-      if (executionEffects.catch === false) {
-        throw e;
-      }
-      if (typeof executionEffects.catch === "function") {
-        executionEffects.catch(e);
-      }
-      onCatch(e);
+      onThrowOrReject(e, true);
       return sideEffects;
     } finally {
       if (!returnedPromise) {

package/src/side_effects/filesystem/spy_filesystem_calls.js

@@ -49,7 +49,7 @@ export const spyFilesystemCalls = (
   const fileDescriptorPathMap = new Map();
   const fileRestoreMap = new Map();
   const dirRestoreMap = new Map();
-  const onWriteFileDone = (fileUrl, stateBefore, stateAfter) => {
+  const onFileMutationDone = (stateBefore, stateAfter) => {
     if (!stateAfter.found) {
       // seems to be possible somehow
       return;
@@ -58,39 +58,42 @@ export const spyFilesystemCalls = (
     // - writing file for the 1st time
     // - updating file content
     // the important part is the file content in the end of the function execution
-    const reason =
-      !stateBefore.found && stateAfter.found
-        ? "created"
-        : Buffer.compare(stateBefore.buffer, stateAfter.buffer)
-          ? "content_modified"
-          : stateBefore.mtimeMs === stateAfter.mtimeMs
-            ? ""
-            : "mtime_modified";
-    if (!reason) {
+    let reason;
+    if (!stateBefore.found && stateAfter.found) {
+      reason = "created";
+    } else if (Buffer.compare(stateBefore.buffer, stateAfter.buffer)) {
+      reason = "content_modified";
+    } else if (stateBefore.mtimeMs !== stateAfter.mtimeMs) {
+      reason = "mtime_modified";
+    } else if (stateBefore.url !== stateAfter.url) {
+      reason = "moved";
+    } else {
       // file is exactly the same
       // function did not have any effect on the file
       return;
     }
-    const action = getAction(fileUrl);
+    const beforeUrl = stateBefore.url;
+    const afterUrl = stateAfter.url;
+    const action = getAction(beforeUrl);
     const shouldCompare =
       action === "compare" ||
       action === "compare_presence_only" ||
       action === true;
     if (action === "undo" || shouldCompare) {
-      if (undoFilesystemSideEffects && !fileRestoreMap.has(fileUrl)) {
+      if (undoFilesystemSideEffects && !fileRestoreMap.has(beforeUrl)) {
         if (stateBefore.found) {
-          fileRestoreMap.set(fileUrl, () => {
-            writeFileSync(fileUrl, stateBefore.buffer);
+          fileRestoreMap.set(beforeUrl, () => {
+            writeFileSync(beforeUrl, stateBefore.buffer);
           });
         } else {
-          fileRestoreMap.set(fileUrl, () => {
-            removeFileSync(fileUrl, { allowUseless: true });
+          fileRestoreMap.set(beforeUrl, () => {
+            removeFileSync(beforeUrl, { allowUseless: true });
           });
         }
       }
     }
     if (shouldCompare) {
-      onWriteFile(fileUrl, stateAfter.buffer, reason);
+      onWriteFile(afterUrl, stateAfter.buffer, reason);
     }
     // "ignore", false, anything else
   };
@@ -121,9 +124,9 @@ export const spyFilesystemCalls = (
   };
   const restoreCallbackSet = new Set();
 
-  const getFileStateWithinHook = (fileUrl) => {
+  const getFileStateWithinHook = (filePath) => {
     return disableHooksWhileCalling(
-      () => getFileState(fileUrl),
+      () => getFileState(filePath),
       [openHook, closeHook],
     );
   };
@@ -208,14 +211,13 @@ export const spyFilesystemCalls = (
             fileDescriptorPathMap.delete(fileDescriptor);
             return;
           }
-          const fileUrl = pathToFileURL(filePath);
           if (buffer) {
-            onReadFile(String(fileUrl));
+            onReadFile(filePath);
           }
           fileDescriptorPathMap.delete(fileDescriptor);
           filesystemStateInfoMap.delete(filePath);
-          const stateAfter = getFileStateWithinHook(fileUrl);
-          onWriteFileDone(String(fileUrl), stateBefore, stateAfter);
+          const stateAfter = getFileStateWithinHook(filePath);
+          onFileMutationDone(stateBefore, stateAfter);
         },
       };
     },
@@ -225,12 +227,11 @@ export const spyFilesystemCalls = (
     _internalFs,
     "writeFileUtf8",
     (filePath) => {
-      const fileUrl = pathToFileURL(filePath);
-      const stateBefore = getFileStateWithinHook(fileUrl);
+      const stateBefore = getFileStateWithinHook(filePath);
       return {
         return: () => {
-          const stateAfter = getFileStateWithinHook(fileUrl);
-          onWriteFileDone(String(fileUrl), stateBefore, stateAfter);
+          const stateAfter = getFileStateWithinHook(filePath);
+          onFileMutationDone(stateBefore, stateAfter);
         },
       };
     },
@@ -242,12 +243,44 @@ export const spyFilesystemCalls = (
       },
     };
   });
+  const copyFileHook = hookIntoMethod(
+    _internalFs,
+    "copyFile",
+    (fromPath, toPath) => {
+      const stateBefore = getFileStateWithinHook(fromPath);
+      return {
+        return: () => {
+          const stateAfter = getFileStateWithinHook(toPath);
+          onFileMutationDone(stateBefore, stateAfter);
+        },
+      };
+    },
+    { execute: METHOD_EXECUTION_NODE_CALLBACK },
+  );
+  const renameHook = hookIntoMethod(
+    _internalFs,
+    "rename",
+    (fromPath, toPath) => {
+      const stateBefore = getFileStateWithinHook(fromPath);
+      return {
+        return: () => {
+          const stateAfter = getFileStateWithinHook(toPath);
+          onFileMutationDone(stateBefore, stateAfter);
+        },
+      };
+    },
+    {
+      execute: METHOD_EXECUTION_NODE_CALLBACK,
+    },
+  );
   restoreCallbackSet.add(() => {
     mkdirHook.remove();
     openHook.remove();
     closeHook.remove();
     writeFileUtf8Hook.remove();
     unlinkHook.remove();
+    copyFileHook.remove();
+    renameHook.remove();
   });
   return {
     restore: () => {
@@ -275,11 +308,13 @@ export const spyFilesystemCalls = (
   };
 };
 
-const getFileState = (file) => {
+const getFileState = (filePath) => {
+  const fileUrl = pathToFileURL(filePath);
   try {
-    const fileBuffer = readFileSync(file);
-    const { mtimeMs } = statSync(file);
+    const fileBuffer = readFileSync(fileUrl);
+    const { mtimeMs } = statSync(fileUrl);
     return {
+      url: String(fileUrl),
       found: true,
       mtimeMs,
       buffer: fileBuffer,
@@ -287,6 +322,7 @@ const getFileState = (file) => {
   } catch (e) {
     if (e.code === "ENOENT") {
       return {
+        url: String(fileUrl),
         found: false,
       };
     }