raycast-rsync-extension 1.0.1

package/src/utils/rsync.test.ts

@@ -0,0 +1,490 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { buildRsyncCommand } from "./rsync";
+import {
+  TransferOptions,
+  TransferDirection,
+  SSHHostConfig,
+} from "../types/server";
+import { homedir } from "os";
+import { join } from "path";
+import { statSync } from "fs";
+import type { PathLike } from "fs";
+import * as os from "os";
+import * as path from "path";
+
+vi.mock("fs", async () => {
+  const actual = await vi.importActual<typeof import("fs")>("fs");
+  return {
+    ...actual,
+    statSync: vi.fn(),
+  };
+});
+
+describe("Rsync Command Builder", () => {
+  const mockHostConfig: SSHHostConfig = {
+    host: "testserver",
+    hostName: "example.com",
+    user: "testuser",
+    port: 22,
+  };
+
+  const configPath = join(homedir(), ".ssh", "config");
+
+  beforeEach(() => {
+    // Mock statSync to return file stats by default
+    vi.mocked(statSync).mockImplementation((path: PathLike) => {
+      const pathStr = path.toString();
+      // Return directory stats for paths ending with "directory" or containing "/dir"
+      if (
+        pathStr.includes("/directory") ||
+        pathStr.endsWith("directory") ||
+        pathStr.includes("/dir/") ||
+        pathStr === "/local/dir"
+      ) {
+        return {
+          isDirectory: () => true,
+          isFile: () => false,
+        } as ReturnType<typeof statSync>;
+      }
+      // Return file stats for other paths
+      return {
+        isDirectory: () => false,
+        isFile: () => true,
+      } as ReturnType<typeof statSync>;
+    });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("buildRsyncCommand", () => {
+    it("should construct upload command with correct format", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path/file.txt",
+        remotePath: "/remote/path/file.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Paths should be properly escaped
+      expect(command).toContain("'/local/path/file.txt'");
+      expect(command).toContain("'testserver':");
+      expect(command).toContain("'/remote/path/file.txt'");
+      expect(command).toMatch(/rsync -e '/);
+    });
+
+    it("should construct download command with correct format", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path/destination",
+        remotePath: "/remote/path/file.txt",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Paths should be properly escaped
+      // For downloads, local destination should have trailing slash to ensure directory is created
+      expect(command).toContain("'/local/path/destination/'");
+      expect(command).toContain("'testserver':");
+      expect(command).toContain("'/remote/path/file.txt'");
+      expect(command).toMatch(/rsync -e '/);
+    });
+
+    it("should include archive flag in command", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/directory",
+        remotePath: "/remote/directory",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      expect(command).toContain("-a");
+    });
+
+    it("should include SSH config in command", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // SSH command should be escaped
+      expect(command).toMatch(/rsync -e '/);
+      expect(command).toContain(configPath);
+    });
+
+    it("should use host alias in command", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Host alias should be escaped
+      expect(command).toContain("'testserver':");
+    });
+
+    it("should handle different host aliases", () => {
+      const customHostConfig: SSHHostConfig = {
+        host: "production-server",
+        hostName: "prod.example.com",
+      };
+
+      const options: TransferOptions = {
+        hostConfig: customHostConfig,
+        localPath: "/local/file",
+        remotePath: "/remote/file",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Host alias should be escaped
+      expect(command).toContain("'production-server':");
+    });
+
+    it("should prevent command injection in localPath", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/tmp/test; rm -rf /",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // The malicious command should be escaped, not executed
+      expect(command).toContain("'/tmp/test; rm -rf /'");
+      // The semicolon should be inside single quotes (escaped), not outside
+      // Check that the path is properly quoted
+      expect(command).toMatch(/'\/(tmp|local)\/test; rm -rf \/'/);
+    });
+
+    it("should prevent command injection in remotePath", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/tmp/test | cat /etc/passwd",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // The malicious command should be escaped
+      expect(command).toContain("'/tmp/test | cat /etc/passwd'");
+    });
+
+    it("should prevent command injection in hostAlias", () => {
+      const maliciousHostConfig: SSHHostConfig = {
+        host: "server; rm -rf /",
+        hostName: "example.com",
+      };
+
+      const options: TransferOptions = {
+        hostConfig: maliciousHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // The malicious host alias should be escaped
+      expect(command).toContain("'server; rm -rf /':");
+    });
+
+    it("should handle paths with spaces", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path with spaces/file.txt",
+        remotePath: "/remote/path with spaces/file.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Paths with spaces should be properly escaped
+      expect(command).toContain("'/local/path with spaces/file.txt'");
+      expect(command).toContain("'/remote/path with spaces/file.txt'");
+    });
+
+    it("should handle paths with single quotes", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/file'name.txt",
+        remotePath: "/remote/file'name.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Paths with single quotes should be properly escaped
+      expect(command).toContain("'/local/file'\\''name.txt'");
+      expect(command).toContain("'/remote/file'\\''name.txt'");
+    });
+
+    it("should include human-readable flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Flag should be included in the combined flags string (e.g., -avzh)
+      expect(command).toMatch(/-[avz]+h/);
+    });
+
+    it("should include progress flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          progress: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Flag should be included in the combined flags string (e.g., -avzP)
+      expect(command).toMatch(/-[avz]+P/);
+    });
+
+    it("should include delete flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      expect(command).toContain("--delete");
+    });
+
+    it("should include all optional flags when all enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Combined short flags should include h and P (e.g., -avzhP)
+      expect(command).toMatch(/-[avz]+hP/);
+      expect(command).toContain("--delete");
+      // Base flags should be present
+      expect(command).toMatch(/-[avz]+/);
+    });
+
+    it("should not include optional flags when disabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: false,
+          progress: false,
+          delete: false,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Extract the flags part (between -e and paths)
+      // Note: -e argument is now escaped with single quotes
+      const flagsMatch = command.match(/rsync -e '[^']+' (-[^ ]+)/);
+      expect(flagsMatch).not.toBeNull();
+      const flags = flagsMatch![1];
+
+      // Optional flags should not be present
+      expect(flags).not.toContain("h");
+      expect(flags).not.toContain("P");
+      expect(command).not.toContain("--delete");
+      // Base flags should still be present
+      expect(flags).toContain("a");
+      expect(flags).toContain("v");
+      expect(flags).toContain("z");
+    });
+
+    it("should normalize directory paths for upload - remove trailing slash from source, add to destination", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/directory",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Source directory should not have trailing slash
+      expect(command).toContain("'/local/directory'");
+      expect(command).not.toContain("'/local/directory/'");
+      // Destination should have trailing slash
+      expect(command).toContain("'/remote/path/'");
+    });
+
+    it("should normalize directory paths for upload when source has trailing slash", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/directory/",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Source directory should not have trailing slash (removed)
+      expect(command).toContain("'/local/directory'");
+      expect(command).not.toContain("'/local/directory/'");
+      // Destination should have trailing slash
+      expect(command).toContain("'/remote/path/'");
+    });
+
+    it("should not modify file paths for upload", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path/file.txt",
+        remotePath: "/remote/path/file.txt",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // File paths should remain unchanged
+      expect(command).toContain("'/local/path/file.txt'");
+      expect(command).toContain("'/remote/path/file.txt'");
+      expect(command).not.toContain("'/remote/path/file.txt/'");
+    });
+
+    it("should normalize paths for download - add trailing slash to local destination, remove from remote source", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path/destination",
+        remotePath: "/remote/directory",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Local destination should have trailing slash
+      expect(command).toContain("'/local/path/destination/'");
+      // Remote source should not have trailing slash
+      expect(command).toContain("'/remote/directory'");
+      expect(command).not.toContain("'/remote/directory/'");
+    });
+
+    it("should normalize paths for download when remote has trailing slash", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path/destination",
+        remotePath: "/remote/directory/",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Local destination should have trailing slash
+      expect(command).toContain("'/local/path/destination/'");
+      // Remote source should not have trailing slash (removed)
+      expect(command).toContain("'/remote/directory'");
+      expect(command).not.toContain("'/remote/directory/'");
+    });
+
+    it("should handle root path correctly", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Root path should remain as "/" (not modified)
+      expect(command).toContain("'/'");
+    });
+
+    it("should expand tilde in local paths for upload", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "~/Documents/file.txt",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Tilde should be expanded to home directory (use homedir() to get actual path)
+      const expectedPath = path.join(os.homedir(), "Documents/file.txt");
+      expect(command).toContain(`'${expectedPath}'`);
+      // Should not contain literal ~
+      expect(command).not.toContain("'~/");
+    });
+
+    it("should expand tilde in local paths for download", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "~/Desktop",
+        remotePath: "/remote/directory",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Tilde should be expanded to home directory with trailing slash
+      const expectedPath = path.join(os.homedir(), "Desktop") + "/";
+      expect(command).toContain(`'${expectedPath}'`);
+      // Should not contain literal ~
+      expect(command).not.toContain("'~/");
+    });
+
+    it("should expand standalone tilde to home directory", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "~",
+        remotePath: "/remote/path",
+        direction: TransferDirection.DOWNLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Standalone tilde should be expanded to home directory with trailing slash
+      const expectedPath = os.homedir() + "/";
+      expect(command).toContain(`'${expectedPath}'`);
+      // Should not contain literal ~
+      expect(command).not.toContain("'~'");
+    });
+  });
+});