@jsenv/snapshot 2.10.3 → 2.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.10.3",
+  "version": "2.11.1",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -29,16 +29,13 @@
   "files": [
     "/src/"
   ],
-  "scripts": {
-    "test": "node --conditions=development ./scripts/test.mjs"
-  },
   "dependencies": {
     "@jsenv/assert": "4.4.1",
     "@jsenv/ast": "6.2.17",
-    "@jsenv/exception": "1.1.2",
+    "@jsenv/exception": "1.1.3",
     "@jsenv/humanize": "1.2.8",
-    "@jsenv/filesystem": "4.10.2",
-    "@jsenv/terminal-recorder": "1.4.7",
+    "@jsenv/filesystem": "4.10.3",
+    "@jsenv/terminal-recorder": "1.4.8",
     "@jsenv/urls": "2.5.2",
     "@jsenv/utils": "2.1.2",
     "ansi-regex": "6.0.1",

package/src/side_effects/create_capture_side_effects.js

@@ -4,12 +4,17 @@ 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,
@@ -21,6 +26,7 @@ export const createCaptureSideEffects = ({
       return: false,
     };
   }
+  executionEffects = { ...executionEffectsDefault, ...executionEffects };
 
   const detectors = [];
   if (logEffects) {

package/src/side_effects/filesystem/spy_filesystem_calls.js

@@ -49,6 +49,25 @@ export const spyFilesystemCalls = (
   const fileDescriptorPathMap = new Map();
   const fileRestoreMap = new Map();
   const dirRestoreMap = new Map();
+
+  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
@@ -58,45 +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
-    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
+    const reason = getMutationReason(stateBefore, stateAfter);
+    if (!reason) {
       return;
     }
-    const beforeUrl = stateBefore.url;
-    const afterUrl = stateAfter.url;
-    const action = getAction(beforeUrl);
+    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(beforeUrl)) {
-        if (stateBefore.found) {
-          fileRestoreMap.set(beforeUrl, () => {
-            writeFileSync(beforeUrl, stateBefore.buffer);
-          });
-        } else {
-          fileRestoreMap.set(beforeUrl, () => {
-            removeFileSync(beforeUrl, { 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(afterUrl, stateAfter.buffer, reason);
+      notify();
     }
-    // "ignore", false, anything else
   };
+
   const onWriteDirectoryDone = (directoryUrl) => {
     const action = getAction(directoryUrl);
     const shouldCompare =
@@ -217,7 +252,7 @@ export const spyFilesystemCalls = (
           fileDescriptorPathMap.delete(fileDescriptor);
           filesystemStateInfoMap.delete(filePath);
           const stateAfter = getFileStateWithinHook(filePath);
-          onFileMutationDone(stateBefore, stateAfter);
+          onWriteFileDone(stateBefore, stateAfter);
         },
       };
     },
@@ -231,7 +266,7 @@ export const spyFilesystemCalls = (
       return {
         return: () => {
           const stateAfter = getFileStateWithinHook(filePath);
-          onFileMutationDone(stateBefore, stateAfter);
+          onWriteFileDone(stateBefore, stateAfter);
         },
       };
     },
@@ -247,11 +282,11 @@ export const spyFilesystemCalls = (
     _internalFs,
     "copyFile",
     (fromPath, toPath) => {
-      const stateBefore = getFileStateWithinHook(fromPath);
+      const toStateBefore = getFileStateWithinHook(toPath);
       return {
         return: () => {
-          const stateAfter = getFileStateWithinHook(toPath);
-          onFileMutationDone(stateBefore, stateAfter);
+          const toStateAfter = getFileStateWithinHook(toPath);
+          onCopyFileDone(toStateBefore, toStateAfter);
         },
       };
     },
@@ -261,11 +296,12 @@ export const spyFilesystemCalls = (
     _internalFs,
     "rename",
     (fromPath, toPath) => {
-      const stateBefore = getFileStateWithinHook(fromPath);
+      const fromStateBefore = getFileStateWithinHook(fromPath);
+      const toStateBefore = getFileStateWithinHook(toPath);
       return {
         return: () => {
-          const stateAfter = getFileStateWithinHook(toPath);
-          onFileMutationDone(stateBefore, stateAfter);
+          const toStateAfter = getFileStateWithinHook(toPath);
+          onMoveFileDone(fromStateBefore, toStateBefore, toStateAfter);
         },
       };
     },

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"