pushwork 2.0.0-a.sub.0 → 2.0.0-preview

package/test/unit/deletion-behavior.test.ts

@@ -1,249 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { tmpdir } from "os";
-import {
-  readFileContent,
-  writeFileContent,
-  removePath,
-  pathExists,
-} from "../../src/utils";
-import { SnapshotManager } from "../../src/core/snapshot";
-import { ChangeDetector } from "../../src/core/change-detection";
-
-describe("File Deletion Behavior", () => {
-  let testDir: string;
-  let snapshotManager: SnapshotManager;
-
-  beforeEach(async () => {
-    testDir = await fs.mkdtemp(path.join(tmpdir(), "deletion-test-"));
-    snapshotManager = new SnapshotManager(testDir);
-    // Create a minimal change detector for testing (without Automerge repo)
-    new ChangeDetector(null as any, testDir, []);
-  });
-
-  afterEach(async () => {
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  describe("Basic File Deletion", () => {
-    it("should read TypeScript files correctly before deletion", async () => {
-      const tsFile = path.join(testDir, "component.ts");
-      const content = "interface User { name: string; }";
-      await writeFileContent(tsFile, content);
-
-      const result = await readFileContent(tsFile);
-      expect(typeof result).toBe("string");
-      expect(result).toBe(content);
-    });
-
-    it("should handle file deletion through removePath", async () => {
-      const filePath = path.join(testDir, "test.txt");
-      await writeFileContent(filePath, "test content");
-
-      expect(await pathExists(filePath)).toBe(true);
-
-      await removePath(filePath);
-
-      expect(await pathExists(filePath)).toBe(false);
-    });
-
-    it("should handle directory deletion through removePath", async () => {
-      const dirPath = path.join(testDir, "subdir");
-      const filePath = path.join(dirPath, "file.txt");
-
-      await fs.mkdir(dirPath);
-      await writeFileContent(filePath, "content");
-
-      expect(await pathExists(dirPath)).toBe(true);
-      expect(await pathExists(filePath)).toBe(true);
-
-      await removePath(dirPath);
-
-      expect(await pathExists(dirPath)).toBe(false);
-      expect(await pathExists(filePath)).toBe(false);
-    });
-  });
-
-  describe("Snapshot Deletion Behavior", () => {
-    it("should properly remove files from snapshot", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      // Add a file to snapshot
-      snapshotManager.updateFileEntry(snapshot, "test.txt", {
-        path: path.join(testDir, "test.txt"),
-        url: "automerge:test-url" as any,
-        head: ["test-head"] as any,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      expect(snapshot.files.has("test.txt")).toBe(true);
-
-      // Remove file from snapshot
-      snapshotManager.removeFileEntry(snapshot, "test.txt");
-
-      expect(snapshot.files.has("test.txt")).toBe(false);
-      expect(snapshot.files.size).toBe(0);
-    });
-
-    it("should handle removing non-existent files gracefully", () => {
-      const snapshot = snapshotManager.createEmpty();
-
-      // Should not throw when removing non-existent file
-      expect(() => {
-        snapshotManager.removeFileEntry(snapshot, "nonexistent.txt");
-      }).not.toThrow();
-
-      expect(snapshot.files.size).toBe(0);
-    });
-  });
-
-  describe("Deletion Scenario Simulation", () => {
-    it("should simulate local file deletion scenario", async () => {
-      // Create a file
-      const filePath = path.join(testDir, "deleteme.txt");
-      const content = "This file will be deleted";
-      await writeFileContent(filePath, content);
-
-      // Verify file exists
-      expect(await pathExists(filePath)).toBe(true);
-      const readContent = await readFileContent(filePath);
-      expect(readContent).toBe(content);
-
-      // Create snapshot with this file
-      const snapshot = snapshotManager.createEmpty();
-      snapshotManager.updateFileEntry(snapshot, "deleteme.txt", {
-        path: filePath,
-        url: "automerge:delete-test" as any,
-        head: ["initial-head"] as any,
-        extension: "txt",
-        mimeType: "text/plain",
-      });
-
-      // Simulate local deletion (user deletes file)
-      await removePath(filePath);
-
-      // Verify file is gone
-      expect(await pathExists(filePath)).toBe(false);
-
-      // Snapshot should still have the file entry (until sync processes the deletion)
-      expect(snapshot.files.has("deleteme.txt")).toBe(true);
-
-      // Simulate sync engine processing the deletion
-      snapshotManager.removeFileEntry(snapshot, "deleteme.txt");
-
-      // Now snapshot should not have the file
-      expect(snapshot.files.has("deleteme.txt")).toBe(false);
-    });
-
-    it("should handle rapid create-delete cycles", async () => {
-      const filePath = path.join(testDir, "rapid.txt");
-
-      // Rapid create-delete cycle
-      for (let i = 0; i < 5; i++) {
-        await writeFileContent(filePath, `content ${i}`);
-        expect(await pathExists(filePath)).toBe(true);
-
-        await removePath(filePath);
-        expect(await pathExists(filePath)).toBe(false);
-      }
-    });
-
-    it("should handle deletion of different file types", async () => {
-      const testFiles = [
-        { name: "text.txt", content: "text content" },
-        { name: "code.ts", content: "interface Test { x: number; }" },
-        { name: "config.json", content: '{"key": "value"}' },
-        { name: "binary.bin", content: new Uint8Array([0x00, 0x01, 0x02]) },
-      ];
-
-      // Create all files
-      for (const file of testFiles) {
-        const filePath = path.join(testDir, file.name);
-        await writeFileContent(filePath, file.content);
-        expect(await pathExists(filePath)).toBe(true);
-      }
-
-      // Delete all files
-      for (const file of testFiles) {
-        const filePath = path.join(testDir, file.name);
-        await removePath(filePath);
-        expect(await pathExists(filePath)).toBe(false);
-      }
-    });
-  });
-
-  describe("Edge Cases and Error Conditions", () => {
-    it("should handle deletion of files with special characters", async () => {
-      const specialFiles = [
-        "file with spaces.txt",
-        "file-with-dashes.txt",
-        "file_with_underscores.txt",
-        "file.with.multiple.dots.txt",
-      ];
-
-      for (const fileName of specialFiles) {
-        const filePath = path.join(testDir, fileName);
-        await writeFileContent(filePath, "test content");
-        expect(await pathExists(filePath)).toBe(true);
-
-        await removePath(filePath);
-        expect(await pathExists(filePath)).toBe(false);
-      }
-    });
-
-    it("should handle deletion of nested directory structures", async () => {
-      // Create nested structure
-      const nestedPath = path.join(testDir, "level1", "level2", "level3");
-      const filePath = path.join(nestedPath, "deep.txt");
-
-      await fs.mkdir(nestedPath, { recursive: true });
-      await writeFileContent(filePath, "deep content");
-
-      expect(await pathExists(filePath)).toBe(true);
-
-      // Delete entire structure from top level
-      await removePath(path.join(testDir, "level1"));
-
-      expect(await pathExists(path.join(testDir, "level1"))).toBe(false);
-      expect(await pathExists(filePath)).toBe(false);
-    });
-
-    it("should handle concurrent deletion attempts", async () => {
-      const filePath = path.join(testDir, "concurrent.txt");
-      await writeFileContent(filePath, "content");
-
-      // Multiple deletion attempts (should not cause errors)
-      const deletions = [
-        removePath(filePath),
-        removePath(filePath),
-        removePath(filePath),
-      ];
-
-      await Promise.all(deletions);
-
-      expect(await pathExists(filePath)).toBe(false);
-    });
-  });
-
-  describe("Debug Information", () => {
-    it("should provide detailed info about deletion behavior", async () => {
-      const filePath = path.join(testDir, "debug.txt");
-      const content = "Debug test content";
-
-      // Create file
-      await writeFileContent(filePath, content);
-
-      // Verify file content
-      const readBack = await readFileContent(filePath);
-      expect(readBack).toBe(content);
-
-      // Delete file
-      await removePath(filePath);
-
-      // Verify deletion
-      const exists = await pathExists(filePath);
-      expect(exists).toBe(false);
-    });
-  });
-});

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

@@ -1,244 +0,0 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { tmpdir } from "os";
-import {
-  getEnhancedMimeType,
-  isEnhancedTextFile,
-  shouldForceAsText,
-  getMimeType,
-} 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);
-
-      // Enhanced MIME detection (fixed)
-      const enhancedMime = getEnhancedMimeType(tsFile);
-      const enhancedIsText = await isEnhancedTextFile(tsFile);
-      const shouldForce = shouldForceAsText(tsFile);
-
-      // 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);
-
-      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 },
-      ];
-
-      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);
-
-        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()
-    });
-  });
-});