raycast-rsync-extension 1.0.1

package/src/e2e/download.e2e.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { validateRemotePath, validateHostConfig } from "../utils/validation";
+import { buildRsyncCommand } from "../utils/rsync";
+import {
+  TransferDirection,
+  TransferOptions,
+  SSHHostConfig,
+} from "../types/server";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+describe("Download E2E Flow", () => {
+  let testLocalDir: string;
+
+  beforeAll(() => {
+    // Create test directory for downloads
+    testLocalDir = path.join(os.tmpdir(), "rsync-e2e-download-" + Date.now());
+    fs.mkdirSync(testLocalDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    // Clean up test directory
+    if (fs.existsSync(testLocalDir)) {
+      fs.rmSync(testLocalDir, { recursive: true, force: true });
+    }
+  });
+
+  it("should complete full download workflow with valid inputs", () => {
+    // This test verifies the complete download workflow
+    // After successful execution, the UI will call popToRoot() to close the extension
+
+    // Step 1: Create mock host config
+    const downloadHost: SSHHostConfig = {
+      host: "downloadserver",
+      hostName: "download.example.com",
+      user: "downloaduser",
+      port: 22,
+      identityFile: "~/.ssh/download_key",
+    };
+
+    // Step 2: Validate remote path
+    const remotePath = "/remote/source/file.txt";
+    const remoteValidation = validateRemotePath(remotePath);
+    expect(remoteValidation.valid).toBe(true);
+    expect(remoteValidation.error).toBeUndefined();
+
+    // Step 3: Validate host config
+    const hostValidation = validateHostConfig(downloadHost);
+    expect(hostValidation.valid).toBe(true);
+    expect(hostValidation.error).toBeUndefined();
+
+    // Step 4: Build rsync command
+    const options: TransferOptions = {
+      hostConfig: downloadHost,
+      localPath: testLocalDir,
+      remotePath: remotePath,
+      direction: TransferDirection.DOWNLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+    expect(command).toContain("rsync");
+    expect(command).toContain("-a");
+    // Host alias is now escaped with single quotes
+    expect(command).toContain("'downloadserver':");
+    // Paths are now escaped with single quotes
+    expect(command).toContain(`'${remotePath}'`);
+    // For downloads, local destination should have trailing slash to ensure directory is created
+    expect(command).toContain(`'${testLocalDir}/'`);
+  });
+
+  it("should handle empty remote path in download workflow", () => {
+    // Try to validate empty remote path
+    const remoteValidation = validateRemotePath("");
+
+    // Should fail validation
+    expect(remoteValidation.valid).toBe(false);
+    expect(remoteValidation.error).toBeDefined();
+    expect(remoteValidation.error).toContain("cannot be empty");
+  });
+
+  it("should handle invalid remote path with control characters", () => {
+    // Try to validate remote path with control characters
+    const invalidPath = "/remote/path\x00/file.txt";
+    const remoteValidation = validateRemotePath(invalidPath);
+
+    // Should fail validation
+    expect(remoteValidation.valid).toBe(false);
+    expect(remoteValidation.error).toBeDefined();
+    expect(remoteValidation.error).toContain("control characters");
+  });
+
+  it("should validate all inputs before allowing download", () => {
+    const downloadHost: SSHHostConfig = {
+      host: "downloadserver",
+      hostName: "download.example.com",
+      user: "downloaduser",
+    };
+
+    // All validations should pass
+    const remoteValidation = validateRemotePath("/remote/file.txt");
+    const hostValidation = validateHostConfig(downloadHost);
+
+    expect(remoteValidation.valid).toBe(true);
+    expect(hostValidation.valid).toBe(true);
+
+    // Should be able to create transfer options
+    const options: TransferOptions = {
+      hostConfig: downloadHost,
+      localPath: testLocalDir,
+      remotePath: "/remote/file.txt",
+      direction: TransferDirection.DOWNLOAD,
+    };
+
+    expect(options).toBeDefined();
+    expect(options.direction).toBe(TransferDirection.DOWNLOAD);
+  });
+
+  it("should handle directory download", () => {
+    const downloadHost: SSHHostConfig = {
+      host: "downloadserver",
+      hostName: "download.example.com",
+    };
+
+    const remoteDir = "/remote/directory";
+    const remoteValidation = validateRemotePath(remoteDir);
+    expect(remoteValidation.valid).toBe(true);
+
+    const options: TransferOptions = {
+      hostConfig: downloadHost,
+      localPath: testLocalDir,
+      remotePath: remoteDir,
+      direction: TransferDirection.DOWNLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+    expect(command).toContain("-a");
+    expect(command).toContain(remoteDir);
+  });
+
+  it("should handle host without optional properties", () => {
+    const backupServer: SSHHostConfig = {
+      host: "backup-server",
+      hostName: "backup.example.com",
+      user: "backupuser",
+    };
+
+    // Should validate successfully even without port and identityFile
+    const hostValidation = validateHostConfig(backupServer);
+    expect(hostValidation.valid).toBe(true);
+  });
+
+  it("should handle various remote path formats", () => {
+    const validPaths = [
+      "/absolute/path/file.txt",
+      "relative/path/file.txt",
+      "/path/with spaces/file.txt",
+      "/path/with-dashes/file.txt",
+      "/path/with_underscores/file.txt",
+      "/path/with.dots/file.txt",
+      "~/home/path/file.txt",
+    ];
+
+    validPaths.forEach((remotePath) => {
+      const validation = validateRemotePath(remotePath);
+      expect(validation.valid).toBe(true);
+    });
+  });
+
+  it("should build correct rsync command for download", () => {
+    const downloadHost: SSHHostConfig = {
+      host: "backup",
+      hostName: "backup.example.com",
+      user: "backupuser",
+      port: 2222,
+    };
+
+    const options: TransferOptions = {
+      hostConfig: downloadHost,
+      localPath: testLocalDir,
+      remotePath: "/backup/data.tar.gz",
+      direction: TransferDirection.DOWNLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+
+    // Verify command structure (now uses single quotes for escaping)
+    expect(command).toMatch(/^rsync -e 'ssh -F .+' -avz 'backup':.+ .+$/);
+    expect(command).toContain("'/backup/data.tar.gz'");
+    // For downloads, local destination should have trailing slash to ensure directory is created
+    expect(command).toContain(`'${testLocalDir}/'`);
+  });
+});

package/src/e2e/error-handling.e2e.test.ts

@@ -0,0 +1,292 @@
+import { describe, it, expect } from "vitest";
+import { executeRsync } from "../utils/rsync";
+import {
+  validateLocalPath,
+  validateRemotePath,
+  validateHostConfig,
+  validatePort,
+} from "../utils/validation";
+import {
+  TransferDirection,
+  TransferOptions,
+  SSHHostConfig,
+} from "../types/server";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+describe("Error Handling E2E", () => {
+  describe("Validation Errors", () => {
+    it("should handle missing local file", () => {
+      const nonExistentFile = "/path/that/does/not/exist/file.txt";
+      const validation = validateLocalPath(nonExistentFile);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("File not found");
+    });
+
+    it("should handle empty local path", () => {
+      const validation = validateLocalPath("");
+
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("cannot be empty");
+    });
+
+    it("should handle empty remote path", () => {
+      const validation = validateRemotePath("");
+
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("cannot be empty");
+    });
+
+    it("should handle remote path with control characters", () => {
+      const invalidPath = "/path\x00/file.txt";
+      const validation = validateRemotePath(invalidPath);
+
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("control characters");
+    });
+
+    it("should handle invalid port numbers", () => {
+      const testCases = [
+        { port: 0, shouldFail: true },
+        { port: -1, shouldFail: true },
+        { port: 65536, shouldFail: true },
+        { port: 99999, shouldFail: true },
+        { port: 1, shouldFail: false },
+        { port: 22, shouldFail: false },
+        { port: 65535, shouldFail: false },
+      ];
+
+      testCases.forEach(({ port, shouldFail }) => {
+        const validation = validatePort(port);
+        if (shouldFail) {
+          expect(validation.valid).toBe(false);
+          expect(validation.error).toContain("must be between 1 and 65535");
+        } else {
+          expect(validation.valid).toBe(true);
+        }
+      });
+    });
+
+    it("should handle missing host alias", () => {
+      const invalidHost: SSHHostConfig = {
+        host: "",
+        hostName: "example.com",
+      };
+
+      const validation = validateHostConfig(invalidHost);
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("Host alias is required");
+    });
+
+    it("should handle host with invalid port", () => {
+      const invalidHost: SSHHostConfig = {
+        host: "testhost",
+        hostName: "example.com",
+        port: 70000,
+      };
+
+      const validation = validateHostConfig(invalidHost);
+      expect(validation.valid).toBe(false);
+      expect(validation.error).toContain("must be between 1 and 65535");
+    });
+  });
+
+  describe("Rsync Execution Errors", () => {
+    it("should handle connection to unreachable host", async () => {
+      const mockHost: SSHHostConfig = {
+        host: "unreachable-host",
+        hostName: "192.0.2.1", // TEST-NET-1 (non-routable)
+        user: "testuser",
+      };
+
+      const testDir = path.join(os.tmpdir(), "rsync-test-" + Date.now());
+      fs.mkdirSync(testDir, { recursive: true });
+      const testFile = path.join(testDir, "test.txt");
+      fs.writeFileSync(testFile, "test content");
+
+      const options: TransferOptions = {
+        hostConfig: mockHost,
+        localPath: testFile,
+        remotePath: "/remote/test.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const result = await executeRsync(options);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toBeDefined();
+      expect(result.message.length).toBeGreaterThan(0);
+
+      // Cleanup
+      fs.rmSync(testDir, { recursive: true, force: true });
+    });
+
+    it("should handle invalid hostname", async () => {
+      const mockHost: SSHHostConfig = {
+        host: "invalid-host",
+        hostName: "this-host-does-not-exist-12345.invalid",
+        user: "testuser",
+      };
+
+      const testDir = path.join(os.tmpdir(), "rsync-test-" + Date.now());
+      fs.mkdirSync(testDir, { recursive: true });
+      const testFile = path.join(testDir, "test.txt");
+      fs.writeFileSync(testFile, "test content");
+
+      const options: TransferOptions = {
+        hostConfig: mockHost,
+        localPath: testFile,
+        remotePath: "/remote/test.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const result = await executeRsync(options);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toBeDefined();
+
+      // Cleanup
+      fs.rmSync(testDir, { recursive: true, force: true });
+    });
+
+    it("should handle missing local file in rsync execution", async () => {
+      const mockHost: SSHHostConfig = {
+        host: "test",
+        hostName: "test.example.com",
+      };
+
+      const nonExistentFile =
+        "/tmp/file-that-does-not-exist-" + Date.now() + ".txt";
+
+      const options: TransferOptions = {
+        hostConfig: mockHost,
+        localPath: nonExistentFile,
+        remotePath: "/remote/test.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const result = await executeRsync(options);
+
+      expect(result.success).toBe(false);
+      expect(result.message).toBeDefined();
+    });
+  });
+
+  describe("Complete Error Workflow", () => {
+    it("should validate inputs before attempting transfer", () => {
+      const mockHost: SSHHostConfig = {
+        host: "testhost",
+        hostName: "test.example.com",
+        port: 99999, // Invalid port
+      };
+
+      const nonExistentFile = "/path/does/not/exist.txt";
+      const emptyRemotePath = "";
+
+      // All validations should fail
+      const localValidation = validateLocalPath(nonExistentFile);
+      const remoteValidation = validateRemotePath(emptyRemotePath);
+      const hostValidation = validateHostConfig(mockHost);
+
+      expect(localValidation.valid).toBe(false);
+      expect(remoteValidation.valid).toBe(false);
+      expect(hostValidation.valid).toBe(false);
+
+      // Should not proceed to transfer
+      expect(localValidation.error).toBeDefined();
+      expect(remoteValidation.error).toBeDefined();
+      expect(hostValidation.error).toBeDefined();
+    });
+
+    it("should pass all validations with correct inputs", () => {
+      const testDir = path.join(os.tmpdir(), "rsync-test-" + Date.now());
+      fs.mkdirSync(testDir, { recursive: true });
+      const testFile = path.join(testDir, "test.txt");
+      fs.writeFileSync(testFile, "test content");
+
+      const mockHost: SSHHostConfig = {
+        host: "validhost",
+        hostName: "valid.example.com",
+        user: "validuser",
+        port: 22,
+      };
+
+      const remotePath = "/remote/valid/path.txt";
+
+      // All validations should pass
+      const localValidation = validateLocalPath(testFile);
+      const remoteValidation = validateRemotePath(remotePath);
+      const hostValidation = validateHostConfig(mockHost);
+
+      expect(localValidation.valid).toBe(true);
+      expect(remoteValidation.valid).toBe(true);
+      expect(hostValidation.valid).toBe(true);
+
+      // Cleanup
+      fs.rmSync(testDir, { recursive: true, force: true });
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle paths with special characters", () => {
+      const specialPaths = [
+        "/path/with spaces/file.txt",
+        "/path/with-dashes/file.txt",
+        "/path/with_underscores/file.txt",
+        "/path/with.dots/file.txt",
+        "/path/with(parentheses)/file.txt",
+        "/path/with[brackets]/file.txt",
+      ];
+
+      specialPaths.forEach((remotePath) => {
+        const validation = validateRemotePath(remotePath);
+        expect(validation.valid).toBe(true);
+      });
+    });
+
+    it("should handle various port edge cases", () => {
+      const portTests = [
+        { port: 1, valid: true },
+        { port: 22, valid: true },
+        { port: 80, valid: true },
+        { port: 443, valid: true },
+        { port: 8080, valid: true },
+        { port: 65535, valid: true },
+        { port: 0, valid: false },
+        { port: -1, valid: false },
+        { port: 65536, valid: false },
+        { port: 1.5, valid: false }, // Non-integer
+      ];
+
+      portTests.forEach(({ port, valid }) => {
+        const validation = validatePort(port);
+        expect(validation.valid).toBe(valid);
+      });
+    });
+
+    it("should handle host config with minimal properties", () => {
+      const minimalHost: SSHHostConfig = {
+        host: "minimal",
+      };
+
+      const validation = validateHostConfig(minimalHost);
+      expect(validation.valid).toBe(true);
+    });
+
+    it("should handle host config with all properties", () => {
+      const fullHost: SSHHostConfig = {
+        host: "fullhost",
+        hostName: "full.example.com",
+        user: "fulluser",
+        port: 2222,
+        identityFile: "~/.ssh/id_rsa",
+        proxyJump: "jumphost",
+      };
+
+      const validation = validateHostConfig(fullHost);
+      expect(validation.valid).toBe(true);
+    });
+  });
+});