pushwork 1.0.0

package/test/unit/enhanced-mime-detection.test.ts

@@ -0,0 +1,266 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { tmpdir } from "os";
+import {
+  getEnhancedMimeType,
+  isEnhancedTextFile,
+  shouldForceAsText,
+  getMimeType,
+  isTextFile,
+} from "../../src/utils";
+
+describe("Enhanced MIME Detection", () => {
+  let testDir: string;
+
+  beforeEach(async () => {
+    testDir = await fs.mkdtemp(path.join(tmpdir(), "enhanced-mime-test-"));
+  });
+
+  afterEach(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("Enhanced vs Standard MIME Detection", () => {
+    it("should fix TypeScript file MIME detection", async () => {
+      const tsFile = path.join(testDir, "test.ts");
+      await fs.writeFile(tsFile, "interface User { name: string; }");
+
+      // Standard MIME detection (broken)
+      const standardMime = getMimeType(tsFile);
+      const standardIsText = await isTextFile(tsFile);
+
+      // Enhanced MIME detection (fixed)
+      const enhancedMime = getEnhancedMimeType(tsFile);
+      const enhancedIsText = await isEnhancedTextFile(tsFile);
+      const shouldForce = shouldForceAsText(tsFile);
+
+      console.log("TypeScript file (.ts) detection:");
+      console.log(`  Standard MIME: ${standardMime}, Text: ${standardIsText}`);
+      console.log(
+        `  Enhanced MIME: ${enhancedMime}, Text: ${enhancedIsText}, Force: ${shouldForce}`
+      );
+
+      // Verify the fix
+      expect(enhancedMime).toBe("text/typescript"); // Fixed!
+      expect(enhancedIsText).toBe(true); // Fixed!
+      expect(shouldForce).toBe(true); // Force TypeScript as text
+
+      // Show the original problem still exists with standard detection
+      expect(standardMime).toBe("video/mp2t"); // The original problem
+    });
+
+    it("should fix TSX file MIME detection", async () => {
+      const tsxFile = path.join(testDir, "Component.tsx");
+      await fs.writeFile(tsxFile, "export const App = () => <div>Hello</div>;");
+
+      const standardMime = getMimeType(tsxFile);
+      const enhancedMime = getEnhancedMimeType(tsxFile);
+      const enhancedIsText = await isEnhancedTextFile(tsxFile);
+
+      console.log("TSX file detection:");
+      console.log(`  Standard MIME: ${standardMime}`);
+      console.log(`  Enhanced MIME: ${enhancedMime}, Text: ${enhancedIsText}`);
+
+      expect(enhancedMime).toBe("text/tsx"); // Fixed!
+      expect(enhancedIsText).toBe(true); // Fixed!
+      expect(standardMime).toBe("application/octet-stream"); // Original problem
+    });
+
+    it("should handle Vue.js single file components", async () => {
+      const vueFile = path.join(testDir, "App.vue");
+      await fs.writeFile(
+        vueFile,
+        `
+<template>
+  <div>{{ message }}</div>
+</template>
+
+<script>
+export default {
+  data() {
+    return { message: 'Hello Vue!' }
+  }
+}
+</script>
+
+<style scoped>
+div { color: blue; }
+</style>
+`
+      );
+
+      const enhancedMime = getEnhancedMimeType(vueFile);
+      const enhancedIsText = await isEnhancedTextFile(vueFile);
+
+      expect(enhancedMime).toBe("text/vue");
+      expect(enhancedIsText).toBe(true);
+    });
+
+    it("should handle modern CSS preprocessors correctly", async () => {
+      const testCases = [
+        { file: "styles.scss", expectedMime: "text/scss" },
+        { file: "styles.sass", expectedMime: "text/sass" },
+        { file: "styles.less", expectedMime: "text/less" },
+        { file: "styles.styl", expectedMime: "text/stylus" },
+      ];
+
+      for (const testCase of testCases) {
+        const filePath = path.join(testDir, testCase.file);
+        await fs.writeFile(
+          filePath,
+          "$primary-color: #007bff;\n.button { color: $primary-color; }"
+        );
+
+        const enhancedMime = getEnhancedMimeType(filePath);
+        const enhancedIsText = await isEnhancedTextFile(filePath);
+
+        expect(enhancedMime).toBe(testCase.expectedMime);
+        expect(enhancedIsText).toBe(true);
+      }
+    });
+
+    it("should handle configuration files by filename", async () => {
+      const configFiles = [
+        { filename: "Dockerfile", expectedMime: "text/plain" },
+        { filename: "package.json", expectedMime: "application/json" },
+        { filename: "tsconfig.json", expectedMime: "application/json" },
+        {
+          filename: "webpack.config.js",
+          expectedMime: "application/javascript",
+        },
+      ];
+
+      for (const config of configFiles) {
+        const filePath = path.join(testDir, config.filename);
+        await fs.writeFile(filePath, "# Configuration content");
+
+        const enhancedMime = getEnhancedMimeType(filePath);
+        const enhancedIsText = await isEnhancedTextFile(filePath);
+
+        expect(enhancedMime).toBe(config.expectedMime);
+        expect(enhancedIsText).toBe(true);
+      }
+    });
+  });
+
+  describe("Comprehensive Developer File Support", () => {
+    it("should correctly handle all common developer file types", async () => {
+      const developerFiles = [
+        // JavaScript/TypeScript ecosystem
+        { name: "app.js", mime: "application/javascript", text: true },
+        { name: "app.ts", mime: "text/typescript", text: true },
+        { name: "Component.tsx", mime: "text/tsx", text: true },
+        { name: "Component.jsx", mime: "text/jsx", text: true },
+        { name: "types.d.ts", mime: "text/typescript", text: true },
+        { name: "bundle.mjs", mime: "application/javascript", text: true },
+        { name: "server.cjs", mime: "application/javascript", text: true },
+
+        // Frontend frameworks
+        { name: "App.vue", mime: "text/vue", text: true },
+        { name: "Button.svelte", mime: "text/svelte", text: true },
+
+        // Stylesheets
+        { name: "styles.scss", mime: "text/scss", text: true },
+        { name: "main.css", mime: "text/css", text: true },
+
+        // Documentation
+        { name: "README.md", mime: "text/markdown", text: true },
+        { name: "docs.mdx", mime: "text/markdown", text: true },
+
+        // Config files
+        { name: ".env", mime: "text/plain", text: true },
+        { name: ".gitignore", mime: "text/plain", text: true },
+        { name: "config.toml", mime: "application/toml", text: true },
+
+        // Source maps and build artifacts
+        { name: "app.js.map", mime: "application/json", text: true },
+
+        // Binary files (should not be forced as text)
+        { name: "image.png", mime: "image/png", text: false },
+        { name: "font.woff2", mime: "font/woff2", text: false },
+      ];
+
+      console.log("\nComprehensive Developer File Detection:");
+      console.log("=====================================");
+
+      for (const file of developerFiles) {
+        const filePath = path.join(testDir, file.name);
+
+        // Create appropriate content
+        const content = file.text
+          ? `// Content for ${file.name}\nconst test = true;`
+          : Buffer.from([0x89, 0x50, 0x4e, 0x47]); // PNG-like header
+
+        await fs.writeFile(filePath, content);
+
+        const enhancedMime = getEnhancedMimeType(filePath);
+        const enhancedIsText = await isEnhancedTextFile(filePath);
+        const forced = shouldForceAsText(filePath);
+
+        console.log(
+          `${file.name.padEnd(20)} | MIME: ${enhancedMime.padEnd(
+            25
+          )} | Text: ${enhancedIsText} | Forced: ${forced}`
+        );
+
+        expect(enhancedMime).toBe(file.mime);
+        expect(enhancedIsText).toBe(file.text);
+      }
+    });
+  });
+
+  describe("Edge Cases and Fallbacks", () => {
+    it("should handle files without extensions", async () => {
+      const noExtFile = path.join(testDir, "README");
+      await fs.writeFile(noExtFile, "# This is a README file");
+
+      const enhancedMime = getEnhancedMimeType(noExtFile);
+      const enhancedIsText = await isEnhancedTextFile(noExtFile);
+
+      // Should fall back to content-based detection
+      expect(enhancedMime).toBe("application/octet-stream");
+      expect(enhancedIsText).toBe(true); // Detected as text by content
+    });
+
+    it("should prioritize custom definitions over standard library", async () => {
+      // .ts files are wrongly detected as video/mp2t by standard library
+      const tsFile = path.join(testDir, "test.ts");
+      await fs.writeFile(tsFile, "const x: string = 'test';");
+
+      const standardMime = getMimeType(tsFile);
+      const enhancedMime = getEnhancedMimeType(tsFile);
+
+      expect(standardMime).toBe("video/mp2t"); // Wrong
+      expect(enhancedMime).toBe("text/typescript"); // Corrected by our custom definitions
+    });
+
+    it("should handle empty files correctly", async () => {
+      const emptyFile = path.join(testDir, "empty.ts");
+      await fs.writeFile(emptyFile, "");
+
+      const enhancedMime = getEnhancedMimeType(emptyFile);
+      const enhancedIsText = await isEnhancedTextFile(emptyFile);
+
+      expect(enhancedMime).toBe("text/typescript");
+      expect(enhancedIsText).toBe(true); // Empty files should be treated as text
+    });
+
+    it("should ensure TypeScript files are read as strings (integration test)", async () => {
+      const tsFile = path.join(testDir, "integration.ts");
+      const tsContent = "interface Config { apiUrl: string; timeout: number; }";
+      await fs.writeFile(tsFile, tsContent);
+
+      // Import readFileContent here to test integration
+      const { readFileContent } = await import("../../src/utils");
+
+      const result = await readFileContent(tsFile);
+
+      // Critical: TypeScript files MUST be read as strings
+      expect(typeof result).toBe("string");
+      expect(result).toBe(tsContent);
+
+      // This test would have FAILED before our fix when readFileContent
+      // used isTextFile() instead of isEnhancedTextFile()
+    });
+  });
+});

package/test/unit/snapshot.test.ts

@@ -0,0 +1,431 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as tmp from "tmp";
+import { SnapshotManager } from "../../src/core/snapshot";
+import {
+  SyncSnapshot,
+  SnapshotFileEntry,
+  SnapshotDirectoryEntry,
+} from "../../src/types";
+import { UrlHeads } from "@automerge/automerge-repo";
+
+describe("SnapshotManager", () => {
+  let tmpDir: string;
+  let cleanup: () => void;
+  let snapshotManager: SnapshotManager;
+
+  beforeEach(() => {
+    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = tmpObj.name;
+    cleanup = tmpObj.removeCallback;
+    snapshotManager = new SnapshotManager(tmpDir);
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe("exists", () => {
+    it("should return false when no snapshot exists", async () => {
+      expect(await snapshotManager.exists()).toBe(false);
+    });
+
+    it("should return true when snapshot exists", async () => {
+      const snapshot = snapshotManager.createEmpty();
+      await snapshotManager.save(snapshot);
+
+      expect(await snapshotManager.exists()).toBe(true);
+    });
+  });
+
+  describe("createEmpty", () => {
+    it("should create an empty snapshot", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      expect(snapshot.rootPath).toBe(tmpDir);
+      expect(snapshot.timestamp).toBeGreaterThan(0);
+      expect(snapshot.files.size).toBe(0);
+      expect(snapshot.directories.size).toBe(0);
+    });
+  });
+
+  describe("save and load", () => {
+    it("should save and load empty snapshot", async () => {
+      const originalSnapshot = snapshotManager.createEmpty();
+
+      await snapshotManager.save(originalSnapshot);
+      const loadedSnapshot = await snapshotManager.load();
+
+      expect(loadedSnapshot).not.toBeNull();
+      expect(loadedSnapshot!.rootPath).toBe(originalSnapshot.rootPath);
+      expect(loadedSnapshot!.timestamp).toBe(originalSnapshot.timestamp);
+      expect(loadedSnapshot!.files.size).toBe(0);
+      expect(loadedSnapshot!.directories.size).toBe(0);
+    });
+
+    it("should save and load snapshot with files", async () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      const fileEntry: SnapshotFileEntry = {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:test-url" as any,
+        head: ["test-head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      };
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
+
+      await snapshotManager.save(snapshot);
+      const loadedSnapshot = await snapshotManager.load();
+
+      expect(loadedSnapshot).not.toBeNull();
+      expect(loadedSnapshot!.files.size).toBe(1);
+      expect(loadedSnapshot!.files.get("test.txt")).toEqual(fileEntry);
+    });
+
+    it("should save and load snapshot with directories", async () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      const dirEntry: SnapshotDirectoryEntry = {
+        path: path.join(tmpDir, "subdir"),
+        url: "automerge:dir-url" as any,
+        head: ["dir-head"] as UrlHeads,
+        entries: ["file1.txt", "file2.txt"],
+      };
+
+      snapshotManager.updateDirectoryEntry(snapshot, "subdir", dirEntry);
+
+      await snapshotManager.save(snapshot);
+      const loadedSnapshot = await snapshotManager.load();
+
+      expect(loadedSnapshot).not.toBeNull();
+      expect(loadedSnapshot!.directories.size).toBe(1);
+      expect(loadedSnapshot!.directories.get("subdir")).toEqual(dirEntry);
+    });
+
+    it("should return null when loading non-existent snapshot", async () => {
+      const loadedSnapshot = await snapshotManager.load();
+      expect(loadedSnapshot).toBeNull();
+    });
+  });
+
+  describe("updateFileEntry", () => {
+    it("should add new file entry", () => {
+      const snapshot = snapshotManager.createEmpty();
+      const originalTimestamp = snapshot.timestamp;
+
+      const fileEntry: SnapshotFileEntry = {
+        path: "/test/path/test.txt",
+        url: "automerge:test-url" as any,
+        head: ["test-head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      };
+
+      // Add small delay to ensure timestamp changes
+      const startTime = Date.now();
+      while (Date.now() === startTime) {
+        // Wait for at least 1ms
+      }
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
+
+      expect(snapshot.files.get("test.txt")).toEqual(fileEntry);
+      expect(snapshot.timestamp).toBeGreaterThan(originalTimestamp);
+    });
+
+    it("should update existing file entry", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      const fileEntry1: SnapshotFileEntry = {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:test-url" as any,
+        head: ["old-head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      };
+
+      const fileEntry2: SnapshotFileEntry = {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:test-url" as any,
+        head: ["new-head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      };
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry1);
+      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry2);
+
+      expect(snapshot.files.get("test.txt")).toEqual(fileEntry2);
+      expect(snapshot.files.size).toBe(1);
+    });
+  });
+
+  describe("removeFileEntry", () => {
+    it("should remove file entry", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      const fileEntry: SnapshotFileEntry = {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:test-url" as any,
+        head: ["test-head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      };
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", fileEntry);
+      expect(snapshot.files.size).toBe(1);
+
+      snapshotManager.removeFileEntry(snapshot, "test.txt");
+      expect(snapshot.files.size).toBe(0);
+      expect(snapshot.files.get("test.txt")).toBeUndefined();
+    });
+
+    it("should not fail when removing non-existent file", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.removeFileEntry(snapshot, "nonexistent.txt");
+      expect(snapshot.files.size).toBe(0);
+    });
+  });
+
+  describe("getFilePaths and getDirectoryPaths", () => {
+    it("should return all file paths", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(snapshot, "file1.txt", {
+        path: path.join(tmpDir, "file1.txt"),
+        url: "automerge:url1" as any,
+        head: ["head1"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      snapshotManager.updateFileEntry(snapshot, "file2.txt", {
+        path: path.join(tmpDir, "file2.txt"),
+        url: "automerge:url2" as any,
+        head: ["head2"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      const filePaths = snapshotManager.getFilePaths(snapshot);
+      expect(filePaths.sort()).toEqual(["file1.txt", "file2.txt"]);
+    });
+
+    it("should return all directory paths", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateDirectoryEntry(snapshot, "dir1", {
+        path: path.join(tmpDir, "dir1"),
+        url: "automerge:url1" as any,
+        head: ["head1"] as UrlHeads,
+        entries: [],
+      });
+
+      snapshotManager.updateDirectoryEntry(snapshot, "dir2", {
+        path: path.join(tmpDir, "dir2"),
+        url: "automerge:url2" as any,
+        head: ["head2"] as UrlHeads,
+        entries: [],
+      });
+
+      const dirPaths = snapshotManager.getDirectoryPaths(snapshot);
+      expect(dirPaths.sort()).toEqual(["dir1", "dir2"]);
+    });
+  });
+
+  describe("isTracked", () => {
+    it("should return true for tracked files", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:url" as any,
+        head: ["head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      expect(snapshotManager.isTracked(snapshot, "test.txt")).toBe(true);
+      expect(snapshotManager.isTracked(snapshot, "other.txt")).toBe(false);
+    });
+
+    it("should return true for tracked directories", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateDirectoryEntry(snapshot, "subdir", {
+        path: path.join(tmpDir, "subdir"),
+        url: "automerge:url" as any,
+        head: ["head"] as UrlHeads,
+        entries: [],
+      });
+
+      expect(snapshotManager.isTracked(snapshot, "subdir")).toBe(true);
+      expect(snapshotManager.isTracked(snapshot, "other")).toBe(false);
+    });
+  });
+
+  describe("getStats", () => {
+    it("should return correct statistics", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(snapshot, "file1.txt", {
+        path: path.join(tmpDir, "file1.txt"),
+        url: "automerge:url1" as any,
+        head: ["head1"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      snapshotManager.updateDirectoryEntry(snapshot, "dir1", {
+        path: path.join(tmpDir, "dir1"),
+        url: "automerge:url2" as any,
+        head: ["head2"] as UrlHeads,
+        entries: [],
+      });
+
+      const stats = snapshotManager.getStats(snapshot);
+
+      expect(stats.files).toBe(1);
+      expect(stats.directories).toBe(1);
+      expect(stats.timestamp).toBeInstanceOf(Date);
+      expect(stats.timestamp.getTime()).toBe(snapshot.timestamp);
+    });
+  });
+
+  describe("validate", () => {
+    it("should validate correct snapshot", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      const validation = snapshotManager.validate(snapshot);
+
+      expect(validation.valid).toBe(true);
+      expect(validation.errors).toHaveLength(0);
+    });
+
+    it("should detect invalid timestamp", () => {
+      const snapshot = snapshotManager.createEmpty();
+      snapshot.timestamp = 0;
+
+      const validation = snapshotManager.validate(snapshot);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.errors).toContain("Invalid timestamp");
+    });
+
+    it("should detect missing root path", () => {
+      const snapshot = snapshotManager.createEmpty();
+      snapshot.rootPath = "";
+
+      const validation = snapshotManager.validate(snapshot);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.errors).toContain("Missing root path");
+    });
+
+    it("should detect path conflicts", () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(snapshot, "conflict", {
+        path: path.join(tmpDir, "conflict"),
+        url: "automerge:url1" as any,
+        head: ["head1"] as UrlHeads,
+        extension: "",
+        mimeType: "text/plain",
+      });
+
+      snapshotManager.updateDirectoryEntry(snapshot, "conflict", {
+        path: path.join(tmpDir, "conflict"),
+        url: "automerge:url2" as any,
+        head: ["head2"] as UrlHeads,
+        entries: [],
+      });
+
+      const validation = snapshotManager.validate(snapshot);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.errors).toContain(
+        "Path conflict: conflict exists as both file and directory"
+      );
+    });
+  });
+
+  describe("backup", () => {
+    it("should create backup of existing snapshot", async () => {
+      const snapshot = snapshotManager.createEmpty();
+      await snapshotManager.save(snapshot);
+
+      await snapshotManager.backup();
+
+      // Check that backup file exists
+      const syncToolDir = path.join(tmpDir, ".pushwork");
+      const files = await fs.readdir(syncToolDir);
+      const backupFiles = files.filter((f) =>
+        f.startsWith("snapshot.json.backup.")
+      );
+
+      expect(backupFiles.length).toBe(1);
+    });
+
+    it("should not fail when no snapshot exists", async () => {
+      await snapshotManager.backup(); // Should not throw
+    });
+  });
+
+  describe("clone", () => {
+    it("should create independent copy of snapshot", () => {
+      const originalSnapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(originalSnapshot, "test.txt", {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:url" as any,
+        head: ["head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      const clonedSnapshot = snapshotManager.clone(originalSnapshot);
+
+      // Modify clone
+      snapshotManager.removeFileEntry(clonedSnapshot, "test.txt");
+
+      // Original should be unchanged
+      expect(originalSnapshot.files.size).toBe(1);
+      expect(clonedSnapshot.files.size).toBe(0);
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all data from snapshot", async () => {
+      const snapshot = snapshotManager.createEmpty();
+
+      snapshotManager.updateFileEntry(snapshot, "test.txt", {
+        path: path.join(tmpDir, "test.txt"),
+        url: "automerge:url" as any,
+        head: ["head"] as UrlHeads,
+        extension: "txt",
+        mimeType: "text/plain",
+      });
+
+      snapshotManager.updateDirectoryEntry(snapshot, "subdir", {
+        path: path.join(tmpDir, "subdir"),
+        url: "automerge:url" as any,
+        head: ["head"] as UrlHeads,
+        entries: [],
+      });
+
+      const originalTimestamp = snapshot.timestamp;
+
+      // Add small delay to ensure timestamp difference
+      await new Promise((resolve) => setTimeout(resolve, 1));
+
+      snapshotManager.clear(snapshot);
+
+      expect(snapshot.files.size).toBe(0);
+      expect(snapshot.directories.size).toBe(0);
+      expect(snapshot.timestamp).toBeGreaterThan(originalTimestamp);
+    });
+  });
+});