raycast-rsync-extension 1.0.1

package/src/utils/__tests__/sshConfig.test.ts

@@ -0,0 +1,352 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { join } from "path";
+import {
+  getSSHConfigPath,
+  parseSSHConfig,
+  getHostConfig,
+  clearCache,
+  parseConfigContent,
+} from "../sshConfig";
+
+// Mock os module
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  return {
+    ...actual,
+    homedir: vi.fn(() => "/home/user"),
+  };
+});
+
+// Mock fs module
+// Define state variables that will be accessed by mocks
+let mockFileExists = false;
+let mockFileContent = "";
+let mockFileStats: { mtimeMs: number } | null = null;
+
+// Create mock functions inside the factory to avoid hoisting issues
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof import("node:fs")>("node:fs");
+  const mockExistsSync = vi.fn(() => mockFileExists);
+  const mockReadFileSync = vi.fn(() => mockFileContent);
+  const mockStatSync = vi.fn(() => {
+    if (!mockFileStats) {
+      throw new Error("File not found");
+    }
+    return mockFileStats as any;
+  });
+
+  return {
+    ...actual,
+    existsSync: mockExistsSync,
+    readFileSync: mockReadFileSync,
+    statSync: mockStatSync,
+  };
+});
+
+// Import fs after mocking to get the mocked functions
+import * as fs from "node:fs";
+
+describe("sshConfig", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    clearCache();
+    mockFileExists = false;
+    mockFileContent = "";
+    mockFileStats = null;
+    vi.mocked(fs.existsSync).mockClear();
+    vi.mocked(fs.readFileSync).mockClear();
+    vi.mocked(fs.statSync).mockClear();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("getSSHConfigPath", () => {
+    it("should return the correct SSH config path", () => {
+      const path = getSSHConfigPath();
+      expect(path).toBe(join("/home/user", ".ssh", "config"));
+    });
+  });
+
+  describe("parseConfigContent", () => {
+    it("should parse simple host configuration", () => {
+      const content = `
+Host myserver
+    HostName example.com
+    User myuser
+    Port 22
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(1);
+      expect(hosts[0]).toMatchObject({
+        host: "myserver",
+        hostName: "example.com",
+        user: "myuser",
+        port: 22,
+      });
+    });
+
+    it("should parse multiple hosts", () => {
+      const content = `
+Host server1
+    HostName server1.example.com
+    User user1
+
+Host server2
+    HostName server2.example.com
+    User user2
+    Port 2222
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(2);
+      expect(hosts[0].host).toBe("server1");
+      expect(hosts[1].host).toBe("server2");
+      expect(hosts[1].port).toBe(2222);
+    });
+
+    it("should skip wildcard hosts", () => {
+      const content = `
+Host *
+    User default
+
+Host myserver
+    HostName example.com
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(1);
+      expect(hosts[0].host).toBe("myserver");
+    });
+
+    it("should handle multiple host aliases", () => {
+      const content = `
+Host server1 server2 server3
+    HostName example.com
+    User myuser
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(3);
+      expect(hosts.map((h) => h.host)).toEqual([
+        "server1",
+        "server2",
+        "server3",
+      ]);
+    });
+
+    it("should parse identity file and expand ~", () => {
+      const content = `
+Host myserver
+    HostName example.com
+    IdentityFile ~/.ssh/id_rsa
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts[0].identityFile).toBe("/home/user/.ssh/id_rsa");
+    });
+
+    it("should parse proxy jump", () => {
+      const content = `
+Host myserver
+    HostName example.com
+    ProxyJump jumpbox
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts[0].proxyJump).toBe("jumpbox");
+    });
+
+    it("should skip comments and empty lines", () => {
+      const content = `
+# This is a comment
+Host myserver
+    # Another comment
+    HostName example.com
+    User myuser
+
+Host server2
+    HostName server2.com
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(2);
+    });
+
+    it("should handle global configuration", () => {
+      // Note: The current implementation doesn't support global configuration
+      // This test documents the expected behavior if global config support is added
+      const content = `
+User globaluser
+Port 2222
+
+Host myserver
+    HostName example.com
+`;
+      const hosts = parseConfigContent(content);
+      // Global config is not currently supported, so user and port will be undefined
+      // This test verifies the current behavior
+      expect(hosts[0].hostName).toBe("example.com");
+      // If global config support is added, uncomment these:
+      // expect(hosts[0].user).toBe("globaluser");
+      // expect(hosts[0].port).toBe(2222);
+    });
+
+    it("should handle case-insensitive properties", () => {
+      const content = `
+Host myserver
+    HOSTNAME example.com
+    USER myuser
+    PORT 2222
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts[0].hostName).toBe("example.com");
+      expect(hosts[0].user).toBe("myuser");
+      expect(hosts[0].port).toBe(2222);
+    });
+
+    it("should handle invalid port gracefully", () => {
+      const content = `
+Host myserver
+    HostName example.com
+    Port invalid
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts[0].port).toBeUndefined();
+    });
+
+    it("should return empty array for empty config", () => {
+      const hosts = parseConfigContent("");
+      expect(hosts).toHaveLength(0);
+    });
+
+    it("should handle tabs and spaces for indentation", () => {
+      const content = `
+Host myserver
+	HostName example.com
+    User myuser
+`;
+      const hosts = parseConfigContent(content);
+      expect(hosts).toHaveLength(1);
+      expect(hosts[0].hostName).toBe("example.com");
+      expect(hosts[0].user).toBe("myuser");
+    });
+  });
+
+  describe("parseSSHConfig", () => {
+    it("should return empty array if config file does not exist", () => {
+      mockFileExists = false;
+      clearCache();
+      const hosts = parseSSHConfig();
+      expect(hosts).toHaveLength(0);
+    });
+
+    it("should parse existing config file", () => {
+      const configContent = `
+Host myserver
+    HostName example.com
+    User myuser
+`;
+      clearCache();
+      mockFileExists = true;
+      mockFileContent = configContent;
+      mockFileStats = { mtimeMs: 1234567890 };
+      // Reset the mock implementation to return the content
+      vi.mocked(fs.readFileSync).mockReturnValue(mockFileContent);
+
+      const hosts = parseSSHConfig();
+      expect(hosts).toHaveLength(1);
+    });
+
+    it("should cache parsed config", () => {
+      const configContent = `
+Host myserver
+    HostName example.com
+`;
+      clearCache();
+      mockFileExists = true;
+      mockFileContent = configContent;
+      mockFileStats = { mtimeMs: 1234567890 };
+      vi.mocked(fs.readFileSync).mockReturnValue(mockFileContent);
+      vi.mocked(fs.readFileSync).mockClear();
+
+      parseSSHConfig();
+      parseSSHConfig();
+
+      // Should only read file once due to caching
+      expect(vi.mocked(fs.readFileSync)).toHaveBeenCalledTimes(1);
+    });
+
+    it("should handle read errors gracefully", () => {
+      // Suppress console.error for this test
+      const consoleSpy = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      clearCache();
+
+      mockFileExists = true;
+      mockFileStats = { mtimeMs: 1234567890 };
+      vi.mocked(fs.readFileSync).mockImplementation(() => {
+        throw new Error("Permission denied");
+      });
+
+      const hosts = parseSSHConfig();
+      expect(hosts).toHaveLength(0);
+
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe("getHostConfig", () => {
+    it("should return host config by alias", () => {
+      const configContent = `
+Host myserver
+    HostName example.com
+    User myuser
+`;
+      clearCache();
+      mockFileExists = true;
+      mockFileContent = configContent;
+      mockFileStats = { mtimeMs: 1234567890 };
+      // Reset the mock implementation to return the content
+      vi.mocked(fs.readFileSync).mockReturnValue(mockFileContent);
+
+      const host = getHostConfig("myserver");
+      expect(host).toBeDefined();
+      expect(host?.host).toBe("myserver");
+      expect(host?.hostName).toBe("example.com");
+    });
+
+    it("should return null for non-existent host", () => {
+      const configContent = `
+Host myserver
+    HostName example.com
+`;
+      clearCache();
+      mockFileExists = true;
+      mockFileContent = configContent;
+      mockFileStats = { mtimeMs: 1234567890 };
+      vi.mocked(fs.readFileSync).mockReturnValue(mockFileContent);
+
+      const host = getHostConfig("nonexistent");
+      expect(host).toBeNull();
+    });
+  });
+
+  describe("clearCache", () => {
+    it("should clear the cache", () => {
+      const configContent = `
+Host myserver
+    HostName example.com
+`;
+      clearCache();
+      mockFileExists = true;
+      mockFileContent = configContent;
+      mockFileStats = { mtimeMs: 1234567890 };
+      vi.mocked(fs.readFileSync).mockReturnValue(mockFileContent);
+      vi.mocked(fs.readFileSync).mockClear();
+
+      parseSSHConfig();
+      clearCache();
+      parseSSHConfig();
+
+      // After clearing cache, should read file again
+      expect(vi.mocked(fs.readFileSync)).toHaveBeenCalledTimes(2);
+    });
+  });
+});

package/src/utils/__tests__/validation.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import {
+  validatePort,
+  validateLocalPath,
+  validateRemotePath,
+  validateHostConfig,
+} from "../validation";
+import { SSHHostConfig } from "../../types/server";
+
+// Type definitions for mocked fs module
+type MockedFS = typeof fs & {
+  __setMockFileExists: (exists: boolean) => void;
+  __setMockStats: (stats: fs.Stats | null) => void;
+};
+
+// Mock fs module
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof fs>("node:fs");
+  let mockFileExists = false;
+  let mockStats: fs.Stats | null = null;
+
+  return {
+    ...actual,
+    existsSync: vi.fn(() => mockFileExists),
+    statSync: vi.fn(() => {
+      if (!mockStats) {
+        throw new Error("File not found");
+      }
+      return mockStats;
+    }),
+    __setMockFileExists: (exists: boolean) => {
+      mockFileExists = exists;
+    },
+    __setMockStats: (stats: fs.Stats | null) => {
+      mockStats = stats;
+    },
+  };
+});
+
+describe("validation", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (fs as unknown as MockedFS).__setMockFileExists(false);
+    (fs as unknown as MockedFS).__setMockStats(null);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("validatePort", () => {
+    it("should return valid for valid ports", () => {
+      expect(validatePort(22).valid).toBe(true);
+      expect(validatePort(80).valid).toBe(true);
+      expect(validatePort(443).valid).toBe(true);
+      expect(validatePort(8080).valid).toBe(true);
+      expect(validatePort(65535).valid).toBe(true);
+      expect(validatePort(1).valid).toBe(true);
+    });
+
+    it("should return invalid for invalid ports", () => {
+      expect(validatePort(0).valid).toBe(false);
+      expect(validatePort(-1).valid).toBe(false);
+      expect(validatePort(65536).valid).toBe(false);
+      expect(validatePort(100000).valid).toBe(false);
+      expect(validatePort(22.5).valid).toBe(false);
+      expect(validatePort(NaN).valid).toBe(false);
+    });
+  });
+
+  describe("validateLocalPath", () => {
+    it("should return valid if path exists", () => {
+      (fs as unknown as MockedFS).__setMockFileExists(true);
+      const result = validateLocalPath("/valid/path");
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return invalid if path does not exist", () => {
+      (fs as unknown as MockedFS).__setMockFileExists(false);
+      const result = validateLocalPath("/invalid/path");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("File not found");
+    });
+
+    it("should return invalid for empty paths", () => {
+      const result = validateLocalPath("");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Local path cannot be empty");
+    });
+
+    it("should handle whitespace", () => {
+      (fs as unknown as MockedFS).__setMockFileExists(true);
+      const result = validateLocalPath("  /path  ");
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("validateRemotePath", () => {
+    it("should return valid for non-empty paths", () => {
+      expect(validateRemotePath("/home/user").valid).toBe(true);
+      expect(validateRemotePath("file.txt").valid).toBe(true);
+      expect(validateRemotePath("/path/to/file").valid).toBe(true);
+    });
+
+    it("should return invalid for empty paths", () => {
+      expect(validateRemotePath("").valid).toBe(false);
+      expect(validateRemotePath("   ").valid).toBe(false);
+    });
+
+    it("should handle whitespace", () => {
+      expect(validateRemotePath("  /path  ").valid).toBe(true);
+    });
+  });
+
+  describe("validateHostConfig", () => {
+    it("should return valid for complete config", () => {
+      const config: SSHHostConfig = {
+        host: "server1",
+        hostName: "example.com",
+        user: "admin",
+        port: 22,
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should return invalid for missing host alias", () => {
+      const config: SSHHostConfig = {
+        host: "",
+        hostName: "example.com",
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Host alias is required");
+    });
+  });
+});

package/src/utils/preferences.ts

@@ -0,0 +1,24 @@
+import { getPreferenceValues } from "@raycast/api";
+import { RsyncOptions } from "../types/server";
+
+/**
+ * Preferences interface matching package.json preferences
+ */
+export interface RsyncPreferences {
+  rsyncHumanReadable: boolean;
+  rsyncProgress: boolean;
+  rsyncDelete: boolean;
+}
+
+/**
+ * Get rsync preferences from Raycast preferences
+ * @returns RsyncOptions object derived from preferences
+ */
+export function getRsyncPreferences(): RsyncOptions {
+  const preferences = getPreferenceValues<RsyncPreferences>();
+  return {
+    humanReadable: preferences.rsyncHumanReadable,
+    progress: preferences.rsyncProgress,
+    delete: preferences.rsyncDelete,
+  };
+}