@jsenv/snapshot 1.0.1 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/snapshot",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Snapshot testing",
   "license": "MIT",
   "author": {
@@ -35,9 +35,9 @@
     "test": "node --conditions=development ./scripts/test.mjs"
   },
   "dependencies": {
-    "@jsenv/filesystem": "4.5.0",
+    "@jsenv/filesystem": "4.5.1",
     "@jsenv/urls": "2.2.1",
-    "@jsenv/utils": "2.0.1",
+    "@jsenv/utils": "2.1.0",
     "@jsenv/assert": "2.13.0"
   }
 }

package/src/main.js

@@ -3,6 +3,11 @@ import {
   assertAndNormalizeDirectoryUrl,
   assertAndNormalizeFileUrl,
   comparePathnames,
+  ensureEmptyDirectorySync,
+  removeFileSync,
+  writeFileSync,
+  removeDirectorySync,
+  writeFileStructureSync,
 } from "@jsenv/filesystem";
 import { urlToFilename, urlToRelativeUrl } from "@jsenv/urls";
 import { CONTENT_TYPE } from "@jsenv/utils/src/content_type/content_type.js";
@@ -18,13 +23,54 @@ export const takeDirectorySnapshot = (directoryUrl) => {
   directoryUrl = assertAndNormalizeDirectoryUrl(directoryUrl);
   directoryUrl = new URL(directoryUrl);
 
+  const expectedDirectorySnapshot = createDirectorySnapshot(directoryUrl);
+  ensureEmptyDirectorySync(directoryUrl);
+  return {
+    addFile: (relativeUrl, content) => {
+      writeFileSync(new URL(relativeUrl, directoryUrl), content);
+    },
+    compare: () => {
+      const actualDirectorySnapshot = createDirectorySnapshot(directoryUrl);
+      compareSnapshots(actualDirectorySnapshot, expectedDirectorySnapshot);
+    },
+    restore: () => {
+      if (expectedDirectorySnapshot.notFound) {
+        removeDirectorySync(directoryUrl, {
+          recursive: true,
+          allowUseless: true,
+        });
+        return;
+      }
+      if (expectedDirectorySnapshot.empty) {
+        ensureEmptyDirectorySync(directoryUrl);
+        return;
+      }
+
+      const fileStructure = {};
+      Object.keys(expectedDirectorySnapshot.fileSnapshots).forEach(
+        (relativeUrl) => {
+          const fileSnapshot =
+            expectedDirectorySnapshot.fileSnapshots[relativeUrl];
+          if (!fileSnapshot.empty) {
+            fileStructure[relativeUrl] = fileSnapshot.content;
+          }
+        },
+      );
+      writeFileStructureSync(
+        directoryUrl,
+        expectedDirectorySnapshot.fileStructure,
+      );
+    },
+  };
+};
+const createDirectorySnapshot = (directoryUrl) => {
   const directorySnapshot = {
     [snapshotSymbol]: true,
     empty: false,
     type: "directory",
     url: directoryUrl.href,
     notFound: false,
-    fileStructure: {},
+    fileSnapshots: {},
   };
 
   let stat;
@@ -46,7 +92,7 @@ export const takeDirectorySnapshot = (directoryUrl) => {
     }
   }
 
-  const snapshotNaturalOrder = {};
+  const fileSnapshotsNaturalOrder = {};
   const visitDirectory = (url) => {
     try {
       const directoryContent = readdirSync(url);
@@ -58,7 +104,7 @@ export const takeDirectorySnapshot = (directoryUrl) => {
           return;
         }
         const relativeUrl = urlToRelativeUrl(contentUrl, directoryUrl);
-        snapshotNaturalOrder[relativeUrl] = takeFileSnapshot(contentUrl);
+        fileSnapshotsNaturalOrder[relativeUrl] = createFileSnapshot(contentUrl);
       });
     } catch (e) {
       if (e && e.code === "ENOENT") {
@@ -69,18 +115,37 @@ export const takeDirectorySnapshot = (directoryUrl) => {
   };
   visitDirectory(directoryUrl);
 
-  const relativeUrls = Object.keys(snapshotNaturalOrder);
+  const relativeUrls = Object.keys(fileSnapshotsNaturalOrder);
   relativeUrls.sort(comparePathnames);
   relativeUrls.forEach((relativeUrl) => {
-    directorySnapshot.fileStructure[relativeUrl] =
-      snapshotNaturalOrder[relativeUrl];
+    directorySnapshot.fileSnapshots[relativeUrl] =
+      fileSnapshotsNaturalOrder[relativeUrl];
   });
   return directorySnapshot;
 };
 
 export const takeFileSnapshot = (fileUrl) => {
   fileUrl = assertAndNormalizeFileUrl(fileUrl);
-
+  const expectedFileSnapshot = createFileSnapshot(fileUrl);
+  removeFileSync(fileUrl);
+  return {
+    writeContent: (content) => {
+      writeFileSync(fileUrl, content);
+    },
+    compare: () => {
+      const actualFileSnapshot = createFileSnapshot(fileUrl);
+      compareSnapshots(actualFileSnapshot, expectedFileSnapshot);
+    },
+    restore: () => {
+      if (expectedFileSnapshot.empty) {
+        removeFileSync(fileUrl, { allowUseless: true });
+        return;
+      }
+      writeFileSync(fileUrl, expectedFileSnapshot.content);
+    },
+  };
+};
+const createFileSnapshot = (fileUrl) => {
   const fileSnapshot = {
     [snapshotSymbol]: true,
     empty: false,
@@ -124,7 +189,7 @@ export const takeFileSnapshot = (fileUrl) => {
   return fileSnapshot;
 };
 
-export const compareSnapshots = (currentSnapshot, previousSnapshot) => {
+const compareSnapshots = (currentSnapshot, previousSnapshot) => {
   if (!currentSnapshot || !currentSnapshot[snapshotSymbol]) {
     throw new TypeError(
       `1st argument must be a snapshot, received ${currentSnapshot}`,
@@ -163,10 +228,10 @@ export const compareSnapshots = (currentSnapshot, previousSnapshot) => {
 const snapshotComparers = {
   directory: (currentDirectorySnapshot, previousDirectorySnapshot) => {
     const failureMessage = `comparison with previous directory snapshot failed`;
-    const currentFileStructure = currentDirectorySnapshot.fileStructure;
-    const previousFileStructure = previousDirectorySnapshot.fileStructure;
-    const currentRelativeUrls = Object.keys(currentFileStructure);
-    const previousRelativeUrls = Object.keys(previousFileStructure);
+    const currentFileSnapshots = currentDirectorySnapshot.fileSnapshots;
+    const previousFileSnapshots = previousDirectorySnapshot.fileSnapshots;
+    const currentRelativeUrls = Object.keys(currentFileSnapshots);
+    const previousRelativeUrls = Object.keys(previousFileSnapshots);
 
     // missing_files
     {
@@ -225,8 +290,8 @@ ${extraUrls.join("\n")}`);
     // file contents
     {
       for (const relativeUrl of currentRelativeUrls) {
-        const currentFileSnapshot = currentFileStructure[relativeUrl];
-        const previousFileSnapshot = previousFileStructure[relativeUrl];
+        const currentFileSnapshot = currentFileSnapshots[relativeUrl];
+        const previousFileSnapshot = previousFileSnapshots[relativeUrl];
         compareSnapshots(currentFileSnapshot, previousFileSnapshot);
       }
     }