@jsenv/snapshot 2.10.1 → 2.10.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "2.10.1",
+  "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/filesystem_snapshot.js

@@ -379,24 +379,22 @@ ${extraUrls.join("\n")}`);
       const relativeUrl = urlToRelativeUrl(directoryItemUrl, directoryUrl);
       if (directoryItemStat.isDirectory()) {
         ensurePathnameTrailingSlash(directoryItemUrl);
-        if (!shouldVisitDirectory(directoryItemUrl)) {
+        if (!shouldVisitDirectory(directoryItemUrl.href)) {
           continue;
         }
-        contentSnapshotNaturalOrder[relativeUrl] = createDirectorySnapshot(
-          directoryItemUrl,
-          {
-            shouldVisitDirectory,
-            shouldIncludeFile,
-            shouldCompareFileContent,
-            clean,
-          },
-        );
-        if (clean) {
+        const subdirSnapshot = createDirectorySnapshot(directoryItemUrl, {
+          shouldVisitDirectory,
+          shouldIncludeFile,
+          shouldCompareFileContent,
+          clean,
+        });
+        contentSnapshotNaturalOrder[relativeUrl] = subdirSnapshot;
+        if (clean && subdirSnapshot) {
           removeDirectorySync(directoryItemUrl);
         }
         continue;
       }
-      if (!shouldIncludeFile(directoryItemUrl)) {
+      if (!shouldIncludeFile(directoryItemUrl.href)) {
         continue;
       }
       contentSnapshotNaturalOrder[relativeUrl] =

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

@@ -4,13 +4,14 @@
 // https://github.com/tschaub/mock-fs/issues/348
 
 import {
+  comparePathnames,
   removeDirectorySync,
   removeFileSync,
   writeFileSync,
 } from "@jsenv/filesystem";
 import { URL_META } from "@jsenv/url-meta";
 import { ensurePathnameTrailingSlash, yieldAncestorUrls } from "@jsenv/urls";
-import { readFileSync, statSync } from "node:fs";
+import { readdirSync, readFileSync, statSync } from "node:fs";
 import { pathToFileURL } from "node:url";
 import {
   disableHooksWhileCalling,
@@ -47,7 +48,8 @@ export const spyFilesystemCalls = (
   const filesystemStateInfoMap = new Map();
   const fileDescriptorPathMap = new Map();
   const fileRestoreMap = new Map();
-  const onWriteFileDone = (fileUrl, stateBefore, stateAfter) => {
+  const dirRestoreMap = new Map();
+  const onFileMutationDone = (stateBefore, stateAfter) => {
     if (!stateAfter.found) {
       // seems to be possible somehow
       return;
@@ -56,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
   };
@@ -99,12 +104,16 @@ export const spyFilesystemCalls = (
       action === "compare_presence_only" ||
       action === true;
     if (action === "undo" || shouldCompare) {
-      if (undoFilesystemSideEffects && !fileRestoreMap.has(directoryUrl)) {
-        fileRestoreMap.set(directoryUrl, () => {
-          removeDirectorySync(directoryUrl, {
-            allowUseless: true,
-            recursive: true,
-          });
+      if (undoFilesystemSideEffects && !dirRestoreMap.has(directoryUrl)) {
+        dirRestoreMap.set(directoryUrl, () => {
+          try {
+            const isEmpty = readdirSync(new URL(directoryUrl)).length === 0;
+            if (isEmpty) {
+              removeDirectorySync(directoryUrl, {
+                allowUseless: true,
+              });
+            }
+          } catch {}
         });
       }
     }
@@ -115,9 +124,9 @@ export const spyFilesystemCalls = (
   };
   const restoreCallbackSet = new Set();
 
-  const getFileStateWithinHook = (fileUrl) => {
+  const getFileStateWithinHook = (filePath) => {
     return disableHooksWhileCalling(
-      () => getFileState(fileUrl),
+      () => getFileState(filePath),
       [openHook, closeHook],
     );
   };
@@ -202,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);
         },
       };
     },
@@ -219,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);
         },
       };
     },
@@ -236,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: () => {
@@ -253,15 +292,29 @@ export const spyFilesystemCalls = (
         restore();
       }
       fileRestoreMap.clear();
+      const dirUrls = Array.from(dirRestoreMap.keys());
+      dirUrls.sort((left, right) => {
+        return comparePathnames(
+          new URL(left).pathname,
+          new URL(right).pathname,
+        );
+      });
+      for (const dirUrl of dirUrls) {
+        const restore = dirRestoreMap.get(dirUrl);
+        restore();
+      }
+      dirRestoreMap.clear();
     },
   };
 };
 
-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,
@@ -269,6 +322,7 @@ const getFileState = (file) => {
   } catch (e) {
     if (e.code === "ENOENT") {
       return {
+        url: String(fileUrl),
         found: false,
       };
     }

package/src/side_effects/snapshot_tests.js

@@ -31,10 +31,7 @@ export const snapshotTests = async (
   fnRegisteringTest,
   {
     outFilePattern = "./_[source_filename]/[filename]",
-    filesystemActions = {
-      "**": "compare",
-      // "**/*.svg": "compare_presence_only",
-    },
+    filesystemActions,
     rootDirectoryUrl,
     generatedBy = true,
     executionEffects,
@@ -44,6 +41,7 @@ export const snapshotTests = async (
   } = {},
 ) => {
   filesystemActions = {
+    "**": "compare",
     ...filesystemActions,
     "**/*.svg": "compare_presence_only",
   };