pushwork 1.0.0

package/test/integration/sync-flow.test.ts

@@ -0,0 +1,309 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as tmp from "tmp";
+import { ConfigManager } from "../../src/config";
+import { DirectoryConfig } from "../../src/types";
+
+describe("Sync Flow Integration", () => {
+  let tmpDir: string;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const tmpObj = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = tmpObj.name;
+    cleanup = tmpObj.removeCallback;
+  });
+
+  afterEach(() => {
+    cleanup();
+  });
+
+  describe("Configuration Management", () => {
+    it("should create and load configuration", async () => {
+      const configManager = new ConfigManager(tmpDir);
+
+      // Create test config
+      const testConfig: DirectoryConfig = {
+        sync_server: "wss://test.server.com",
+        sync_enabled: true,
+        defaults: {
+          exclude_patterns: [".git", "*.tmp"],
+          large_file_threshold: "1MB",
+        },
+        diff: {
+          show_binary: false,
+        },
+        sync: {
+          move_detection_threshold: 0.8,
+          prompt_threshold: 0.5,
+          auto_sync: false,
+          parallel_operations: 2,
+        },
+      };
+
+      await configManager.save(testConfig);
+
+      const loadedConfig = await configManager.load();
+      expect(loadedConfig).toEqual(testConfig);
+    });
+
+    it("should merge global and local configurations", async () => {
+      const configManager = new ConfigManager(tmpDir);
+
+      // Create default global config
+      await configManager.createDefaultGlobal();
+
+      // Test directory config
+      const localConfig: DirectoryConfig = {
+        sync_server: "wss://local.server.com",
+        sync_enabled: true,
+        defaults: {
+          exclude_patterns: [".git", "*.tmp"],
+          large_file_threshold: "5MB",
+        },
+        diff: {
+          show_binary: true,
+        },
+        sync: {
+          move_detection_threshold: 0.9,
+          prompt_threshold: 0.6,
+          auto_sync: true,
+          parallel_operations: 1,
+        },
+      };
+
+      await configManager.save(localConfig);
+
+      // Verify merged config
+      const mergedConfig = await configManager.getMerged();
+      expect(mergedConfig.sync_server).toBe("wss://local.server.com");
+      expect(mergedConfig.defaults?.exclude_patterns).toContain(".git");
+      expect(mergedConfig.defaults?.large_file_threshold).toBe("5MB");
+      expect(mergedConfig.diff?.show_binary).toBe(true);
+      expect(mergedConfig.sync?.move_detection_threshold).toBe(0.9);
+    });
+  });
+
+  describe("File System Operations", () => {
+    it("should handle file creation and modification", async () => {
+      // Create initial file structure
+      await fs.mkdir(path.join(tmpDir, "subdir"));
+      await fs.writeFile(path.join(tmpDir, "file1.txt"), "Initial content");
+      await fs.writeFile(
+        path.join(tmpDir, "subdir", "file2.txt"),
+        "Nested content"
+      );
+
+      // Modify files
+      await fs.writeFile(path.join(tmpDir, "file1.txt"), "Modified content");
+      await fs.writeFile(path.join(tmpDir, "new-file.txt"), "New file content");
+
+      // Delete file
+      await fs.unlink(path.join(tmpDir, "subdir", "file2.txt"));
+
+      // Verify final state
+      const file1Content = await fs.readFile(
+        path.join(tmpDir, "file1.txt"),
+        "utf8"
+      );
+      expect(file1Content).toBe("Modified content");
+
+      const newFileContent = await fs.readFile(
+        path.join(tmpDir, "new-file.txt"),
+        "utf8"
+      );
+      expect(newFileContent).toBe("New file content");
+
+      try {
+        await fs.access(path.join(tmpDir, "subdir", "file2.txt"));
+        throw new Error("Deleted file should not exist");
+      } catch (error: any) {
+        // Expected - file should not exist
+        expect(error.code).toBe("ENOENT");
+      }
+    });
+
+    it("should handle binary files", async () => {
+      const binaryData = new Uint8Array([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+      ]); // PNG header
+
+      await fs.writeFile(path.join(tmpDir, "image.png"), binaryData);
+
+      const readData = await fs.readFile(path.join(tmpDir, "image.png"));
+      expect(Array.from(readData)).toEqual(Array.from(binaryData));
+    });
+  });
+
+  describe("Directory Structure Scenarios", () => {
+    it("should handle complex directory structures", async () => {
+      const structure = {
+        src: {
+          components: {
+            "Button.tsx": "export const Button = () => <button />",
+            "Input.tsx": "export const Input = () => <input />",
+          },
+          utils: {
+            "helpers.ts": "export const helper = () => {}",
+            "constants.ts": 'export const API_URL = "http://localhost"',
+          },
+          "index.ts": 'export * from "./components"',
+        },
+        "package.json": '{"name": "test-project", "version": "1.0.0"}',
+        "README.md": "# Test Project\n\nThis is a test project.",
+      };
+
+      await createDirectoryStructure(tmpDir, structure);
+
+      // Verify structure was created
+      const srcExists = await pathExists(path.join(tmpDir, "src"));
+      expect(srcExists).toBe(true);
+
+      const buttonExists = await pathExists(
+        path.join(tmpDir, "src", "components", "Button.tsx")
+      );
+      expect(buttonExists).toBe(true);
+
+      const packageContent = await fs.readFile(
+        path.join(tmpDir, "package.json"),
+        "utf8"
+      );
+      expect(JSON.parse(packageContent).name).toBe("test-project");
+    });
+
+    it("should handle file moves and renames", async () => {
+      // Create initial files
+      await fs.writeFile(path.join(tmpDir, "old-name.txt"), "File content");
+      await fs.mkdir(path.join(tmpDir, "new-dir"));
+
+      // Simulate move operation
+      await fs.rename(
+        path.join(tmpDir, "old-name.txt"),
+        path.join(tmpDir, "new-dir", "new-name.txt")
+      );
+
+      // Verify move
+      const movedFileExists = await pathExists(
+        path.join(tmpDir, "new-dir", "new-name.txt")
+      );
+      expect(movedFileExists).toBe(true);
+
+      const oldFileExists = await pathExists(path.join(tmpDir, "old-name.txt"));
+      expect(oldFileExists).toBe(false);
+
+      const content = await fs.readFile(
+        path.join(tmpDir, "new-dir", "new-name.txt"),
+        "utf8"
+      );
+      expect(content).toBe("File content");
+    });
+  });
+
+  describe("Error Handling", () => {
+    it("should handle permission errors gracefully", async () => {
+      // Create a file
+      const filePath = path.join(tmpDir, "restricted.txt");
+      await fs.writeFile(filePath, "content");
+
+      // Make it read-only (if supported by filesystem)
+      try {
+        await fs.chmod(filePath, 0o444);
+
+        // Try to write - should handle error gracefully
+        try {
+          await fs.writeFile(filePath, "new content");
+          // If this succeeds, the filesystem doesn't enforce permissions
+        } catch (error) {
+          expect(error).toBeDefined();
+          // This is expected behavior
+        }
+      } catch {
+        // chmod may not be supported on all filesystems
+        console.log(
+          "Permission test skipped - filesystem does not support chmod"
+        );
+      }
+    });
+
+    it("should handle corrupted snapshot files", async () => {
+      const configManager = new ConfigManager(tmpDir);
+
+      // Create .pushwork directory
+      const syncToolDir = path.join(tmpDir, ".pushwork");
+      await fs.mkdir(syncToolDir);
+
+      // Write corrupted snapshot
+      const snapshotPath = path.join(syncToolDir, "snapshot.json");
+      await fs.writeFile(snapshotPath, '{"invalid": json}');
+
+      // Should handle gracefully
+      const config = await configManager.load();
+      expect(config).toBeNull();
+    });
+  });
+
+  describe("Performance Scenarios", () => {
+    it("should handle many small files", async () => {
+      const fileCount = 100;
+      const promises: Promise<void>[] = [];
+
+      for (let i = 0; i < fileCount; i++) {
+        const filePath = path.join(tmpDir, `file-${i}.txt`);
+        promises.push(fs.writeFile(filePath, `Content of file ${i}`));
+      }
+
+      await Promise.all(promises);
+
+      // Verify all files were created
+      const files = await fs.readdir(tmpDir);
+      const textFiles = files.filter((f) => f.endsWith(".txt"));
+      expect(textFiles.length).toBe(fileCount);
+    });
+
+    it("should handle large files efficiently", async () => {
+      const largeContent = "x".repeat(1024 * 1024); // 1MB of data
+      const filePath = path.join(tmpDir, "large-file.txt");
+
+      const startTime = Date.now();
+      await fs.writeFile(filePath, largeContent);
+      const writeTime = Date.now() - startTime;
+
+      const readStartTime = Date.now();
+      const readContent = await fs.readFile(filePath, "utf8");
+      const readTime = Date.now() - readStartTime;
+
+      expect(readContent.length).toBe(largeContent.length);
+      expect(writeTime).toBeLessThan(5000); // Should complete within 5 seconds
+      expect(readTime).toBeLessThan(5000); // Should complete within 5 seconds
+    }, 10000); // 10 second timeout
+  });
+});
+
+// Helper functions
+
+async function pathExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createDirectoryStructure(
+  basePath: string,
+  structure: any
+): Promise<void> {
+  for (const [name, content] of Object.entries(structure)) {
+    const fullPath = path.join(basePath, name);
+
+    if (typeof content === "string") {
+      // It's a file
+      await fs.writeFile(fullPath, content);
+    } else {
+      // It's a directory
+      await fs.mkdir(fullPath, { recursive: true });
+      await createDirectoryStructure(fullPath, content);
+    }
+  }
+}

package/test/run-tests.sh

@@ -0,0 +1,225 @@
+#!/bin/bash
+
+# Pushwork Test Runner
+# Provides options to run different test suites
+
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Helper functions
+log_info() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+log_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+log_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+log_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+# Show usage
+show_usage() {
+    echo "Pushwork Test Runner"
+    echo ""
+    echo "Usage: $0 [test-type]"
+    echo ""
+    echo "Test Types:"
+    echo "  full        Run comprehensive integration tests (default)"
+    echo "  clone       Run focused clone functionality tests"
+    echo "  conflict    Run CRDT conflict resolution tests"
+    echo "  deletion    Run deletion sync behavior tests"
+    echo "  deletion-behavior Run comprehensive deletion behavior tests"
+    echo "  unit        Run unit tests"
+    echo "  help        Show this help message"
+    echo ""
+    echo "Examples:"
+    echo "  $0              # Run full integration tests"
+    echo "  $0 full         # Run full integration tests"
+    echo "  $0 clone        # Run clone-specific tests"
+    echo "  $0 conflict     # Run CRDT conflict resolution tests"
+    echo "  $0 unit         # Run unit tests"
+    echo ""
+}
+
+# Check dependencies
+check_dependencies() {
+    log_info "Checking dependencies..."
+    
+    # Check if Node.js is available
+    if ! command -v node &> /dev/null; then
+        log_error "Node.js is not installed"
+        echo "Please install Node.js from https://nodejs.org/"
+        exit 1
+    fi
+    
+    # Check if npm is available
+    if ! command -v npm &> /dev/null; then
+        log_error "npm is not installed"
+        echo "Please install npm"
+        exit 1
+    fi
+    
+    # Check if jq is available (optional for some tests)
+    if ! command -v jq &> /dev/null; then
+        log_warning "jq is not installed - some configuration tests may be skipped"
+        echo "To install jq (optional):"
+        echo "  macOS: brew install jq"
+        echo "  Ubuntu/Debian: apt-get install jq"
+        echo "  Other: https://stedolan.github.io/jq/download/"
+        echo ""
+    fi
+    
+    log_success "Dependencies check complete"
+}
+
+# Run unit tests
+run_unit_tests() {
+    log_info "Running unit tests..."
+    
+    if [ -f "package.json" ] && grep -q "\"test\":" package.json; then
+        npm test
+    else
+        log_warning "No unit tests configured in package.json"
+        
+        # Check for individual test files
+        if ls test/unit/*.test.* 1> /dev/null 2>&1; then
+            log_info "Found unit test files, running with jest/vitest..."
+            if command -v jest &> /dev/null; then
+                jest test/unit/
+            elif command -v vitest &> /dev/null; then
+                vitest run test/unit/
+            else
+                log_error "No test runner found (jest/vitest)"
+                exit 1
+            fi
+        else
+            log_warning "No unit test files found"
+        fi
+    fi
+}
+
+# Run clone tests
+run_clone_tests() {
+    log_info "Running clone functionality tests..."
+    
+    if [ -f "test/integration/clone-test.sh" ]; then
+        ./test/integration/clone-test.sh
+    else
+        log_error "Clone test script not found"
+        exit 1
+    fi
+}
+
+# Run conflict resolution tests
+run_conflict_tests() {
+    log_info "Running conflict resolution tests..."
+    
+    if [ -f "test/integration/conflict-resolution-test.sh" ]; then
+        ./test/integration/conflict-resolution-test.sh
+    else
+        log_error "Conflict resolution test script not found"
+        exit 1
+    fi
+}
+
+# Run deletion sync tests
+run_deletion_tests() {
+    log_info "Running deletion sync behavior tests..."
+    
+    if [ -f "test/integration/deletion-sync-test-simple.sh" ]; then
+        ./test/integration/deletion-sync-test-simple.sh
+    else
+        log_error "Deletion sync test script not found"
+        exit 1
+    fi
+}
+
+# Run comprehensive deletion behavior tests
+run_deletion_behavior_tests() {
+    log_info "Running comprehensive deletion behavior tests..."
+    
+    if [ -f "test/integration/deletion-behavior-test.sh" ]; then
+        ./test/integration/deletion-behavior-test.sh
+    else
+        log_error "Deletion behavior test script not found"
+        exit 1
+    fi
+}
+
+# Run full integration tests
+run_full_tests() {
+    log_info "Running full integration tests..."
+    
+    if [ -f "test/integration/full-integration-test.sh" ]; then
+        ./test/integration/full-integration-test.sh
+    else
+        log_error "Full integration test script not found"
+        exit 1
+    fi
+}
+
+# Main function
+main() {
+    local test_type="${1:-full}"
+    
+    echo "======================================"
+    echo "Pushwork Test Runner"
+    echo "======================================"
+    
+    # Change to project directory if not already there
+    if [ ! -f "package.json" ]; then
+        log_error "Not in project directory (package.json not found)"
+        echo "Please run this script from the project root directory"
+        exit 1
+    fi
+    
+    check_dependencies
+    
+    case "$test_type" in
+        "help"|"-h"|"--help")
+            show_usage
+            exit 0
+            ;;
+        "unit")
+            run_unit_tests
+            ;;
+        "clone")
+            run_clone_tests
+            ;;
+        "conflict")
+            run_conflict_tests
+            ;;
+        "deletion")
+            run_deletion_tests
+            ;;
+        "deletion-behavior")
+            run_deletion_behavior_tests
+            ;;
+        "full")
+            run_full_tests
+            ;;
+        *)
+            log_error "Unknown test type: $test_type"
+            echo ""
+            show_usage
+            exit 1
+            ;;
+    esac
+    
+    log_success "Test run complete!"
+}
+
+# Run main function with all arguments
+main "$@"