@jsenv/snapshot 2.10.2 → 2.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.10.2",
+  "version": "2.11.0",
   "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

@@ -4,17 +4,30 @@ import { createReplaceFilesystemWellKnownValues } from "../filesystem_well_known
 import { filesystemSideEffects } from "./filesystem/filesystem_side_effects.js";
 import { logSideEffects } from "./log/log_side_effects.js";
 
+const executionEffectsDefault = {
+  catch: true,
+  return: true,
+};
+
 export const createCaptureSideEffects = ({
   sourceFileUrl,
   logEffects = true,
   filesystemEffects = true,
   filesystemActions,
-  executionEffects = {},
+  executionEffects = executionEffectsDefault,
   rootDirectoryUrl,
   replaceFilesystemWellKnownValues = createReplaceFilesystemWellKnownValues({
     rootDirectoryUrl,
   }),
 }) => {
+  if (executionEffects === false) {
+    executionEffects = {
+      catch: false,
+      return: false,
+    };
+  }
+  executionEffects = { ...executionEffectsDefault, ...executionEffects };
+
   const detectors = [];
   if (logEffects) {
     detectors.push(logSideEffects(logEffects === true ? {} : logEffects));
@@ -283,6 +296,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 +332,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,26 @@ export const spyFilesystemCalls = (
   const fileDescriptorPathMap = new Map();
   const fileRestoreMap = new Map();
   const dirRestoreMap = new Map();
-  const onWriteFileDone = (fileUrl, stateBefore, stateAfter) => {
+
+  const onWriteFileDone = (stateBefore, stateAfter) =>
+    onFileMutationDone(stateBefore, stateAfter);
+  const onCopyFileDone = (stateBefore, stateAfter) =>
+    onFileMutationDone(stateBefore, stateAfter);
+  const onMoveFileDone = (fromStateBefore, toStateBefore, toStateAfter) => {
+    if (!toStateAfter.found) {
+      // seems to be possible somehow
+      return;
+    }
+    // effect on source file
+    registerUndoAndNotify(fromStateBefore, () => {
+      onRemoveFile(fromStateBefore.url, fromStateBefore.buffer, "move");
+    });
+    // effect on target file
+    registerUndoAndNotify(toStateBefore, () => {
+      onWriteFile(toStateBefore.url, fromStateBefore.buffer, "created");
+    });
+  };
+  const onFileMutationDone = (stateBefore, stateAfter) => {
     if (!stateAfter.found) {
       // seems to be possible somehow
       return;
@@ -58,42 +77,61 @@ 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";
+    const reason = getMutationReason(stateBefore, stateAfter);
     if (!reason) {
-      // file is exactly the same
-      // function did not have any effect on the file
       return;
     }
-    const action = getAction(fileUrl);
+    registerUndoAndNotify(stateBefore, () => {
+      onWriteFile(stateAfter.url, stateAfter.buffer, reason);
+    });
+  };
+  const getMutationReason = (stateBefore, stateAfter) => {
+    if (!stateBefore.found && stateAfter.found) {
+      return "created";
+    }
+    if (Buffer.compare(stateBefore.buffer, stateAfter.buffer)) {
+      return "content_modified";
+    }
+    if (stateBefore.mtimeMs !== stateAfter.mtimeMs) {
+      return "mtime_modified";
+    }
+    // file is exactly the same
+    // function did not have any effect on the file
+    return null;
+  };
+  const registerUndoAndNotify = (stateBefore, notify) => {
+    const url = stateBefore.url;
+    const action = getAction(url);
     const shouldCompare =
       action === "compare" ||
       action === "compare_presence_only" ||
       action === true;
-    if (action === "undo" || shouldCompare) {
-      if (undoFilesystemSideEffects && !fileRestoreMap.has(fileUrl)) {
-        if (stateBefore.found) {
-          fileRestoreMap.set(fileUrl, () => {
-            writeFileSync(fileUrl, stateBefore.buffer);
-          });
-        } else {
-          fileRestoreMap.set(fileUrl, () => {
-            removeFileSync(fileUrl, { allowUseless: true });
-          });
-        }
+    // "ignore", false, anything else
+    undo: {
+      if (!undoFilesystemSideEffects) {
+        break undo;
+      }
+      if (action !== "undo" && !shouldCompare) {
+        break undo;
+      }
+      if (fileRestoreMap.has(url)) {
+        break undo;
+      }
+      if (stateBefore.found) {
+        fileRestoreMap.set(url, () => {
+          writeFileSync(url, stateBefore.buffer);
+        });
+      } else {
+        fileRestoreMap.set(url, () => {
+          removeFileSync(url, { allowUseless: true });
+        });
       }
     }
     if (shouldCompare) {
-      onWriteFile(fileUrl, stateAfter.buffer, reason);
+      notify();
     }
-    // "ignore", false, anything else
   };
+
   const onWriteDirectoryDone = (directoryUrl) => {
     const action = getAction(directoryUrl);
     const shouldCompare =
@@ -121,9 +159,9 @@ export const spyFilesystemCalls = (
   };
   const restoreCallbackSet = new Set();
 
-  const getFileStateWithinHook = (fileUrl) => {
+  const getFileStateWithinHook = (filePath) => {
     return disableHooksWhileCalling(
-      () => getFileState(fileUrl),
+      () => getFileState(filePath),
       [openHook, closeHook],
     );
   };
@@ -208,14 +246,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);
+          onWriteFileDone(stateBefore, stateAfter);
         },
       };
     },
@@ -225,12 +262,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);
+          onWriteFileDone(stateBefore, stateAfter);
         },
       };
     },
@@ -242,12 +278,45 @@ export const spyFilesystemCalls = (
       },
     };
   });
+  const copyFileHook = hookIntoMethod(
+    _internalFs,
+    "copyFile",
+    (fromPath, toPath) => {
+      const toStateBefore = getFileStateWithinHook(toPath);
+      return {
+        return: () => {
+          const toStateAfter = getFileStateWithinHook(toPath);
+          onCopyFileDone(toStateBefore, toStateAfter);
+        },
+      };
+    },
+    { execute: METHOD_EXECUTION_NODE_CALLBACK },
+  );
+  const renameHook = hookIntoMethod(
+    _internalFs,
+    "rename",
+    (fromPath, toPath) => {
+      const fromStateBefore = getFileStateWithinHook(fromPath);
+      const toStateBefore = getFileStateWithinHook(toPath);
+      return {
+        return: () => {
+          const toStateAfter = getFileStateWithinHook(toPath);
+          onMoveFileDone(fromStateBefore, toStateBefore, toStateAfter);
+        },
+      };
+    },
+    {
+      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 +344,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 +358,7 @@ const getFileState = (file) => {
   } catch (e) {
     if (e.code === "ENOENT") {
       return {
+        url: String(fileUrl),
         found: false,
       };
     }

package/src/side_effects/snapshot_tests.js

@@ -12,6 +12,11 @@ import { renderSideEffects, renderSmallLink } from "./render_side_effects.js";
  * @param {Object} snapshotTestsOptions
  * @param {string|url} snapshotTestsOptions.outFilePattern
  * @param {string|url} snapshotTestsOptions.rootDirectoryUrl
+ * @param {Object} [snapshotTestsOptions.executionEffects]
+ * @param {boolean} [snapshotTestsOptions.executionEffects.catch=true]
+ *        Any error thrown by test function is detected and added to side effects
+ * @param {boolean} [snapshotTestsOptions.executionEffects.return=true]
+ *        Test function return value is added to side effects
  * @param {Object} [snapshotTestsOptions.filesystemActions]
  *        Control what to do when there is a file side effect
  *        "compare", "compare_presence_only", "undo", "ignore"