ssh-keyman 1.0.2 → 2.0.0

package/src/__tests__/commands.test.js

@@ -0,0 +1,369 @@
+const fs = require("fs-extra");
+const path = require("path");
+const os = require("os");
+const { mockConsole, mockInquirer } = require("./helpers");
+
+// Mock modules before importing commands
+jest.mock("inquirer");
+jest.mock("inquirer-autocomplete-prompt", () => jest.fn());
+
+describe("commands", () => {
+  let testHomeDir;
+  let originalHomedir;
+  let consoleMock;
+  let SSH_PATH;
+  let KEYMAN_DIR_PATH;
+  let KEYMAN_PATH;
+
+  beforeAll(() => {
+    // Mock os.homedir to return test directory
+    originalHomedir = os.homedir;
+    testHomeDir = path.join(os.tmpdir(), `ssh-keyman-test-home-${Date.now()}`);
+    os.homedir = jest.fn(() => testHomeDir);
+  });
+
+  afterAll(() => {
+    os.homedir = originalHomedir;
+  });
+
+  beforeEach(() => {
+    // Clean up test directory
+    if (fs.existsSync(testHomeDir)) {
+      fs.rmSync(testHomeDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(testHomeDir, { recursive: true });
+
+    SSH_PATH = path.join(testHomeDir, ".ssh");
+    KEYMAN_DIR_PATH = path.join(testHomeDir, ".sshkeyman");
+    KEYMAN_PATH = path.join(KEYMAN_DIR_PATH, ".sshkeyman");
+
+    // Create mock SSH directory
+    fs.mkdirSync(SSH_PATH, { recursive: true });
+    fs.writeFileSync(path.join(SSH_PATH, "id_rsa"), "mock private key");
+    fs.writeFileSync(path.join(SSH_PATH, "id_rsa.pub"), "mock public key");
+
+    consoleMock = mockConsole();
+
+    // Clear module cache to get fresh imports with mocked homedir
+    jest.resetModules();
+  });
+
+  afterEach(() => {
+    consoleMock.restore();
+    if (fs.existsSync(testHomeDir)) {
+      fs.rmSync(testHomeDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("init", () => {
+    it("should initialize ssh-keyman directory structure", () => {
+      const commands = require("../commands");
+      
+      commands.init();
+
+      expect(fs.existsSync(KEYMAN_DIR_PATH)).toBe(true);
+      expect(fs.existsSync(KEYMAN_PATH)).toBe(true);
+      expect(fs.existsSync(path.join(KEYMAN_DIR_PATH, "default"))).toBe(true);
+
+      const keymanContent = JSON.parse(fs.readFileSync(KEYMAN_PATH, "utf8"));
+      expect(keymanContent).toEqual({
+        active: "default",
+        available: ["default"],
+      });
+    });
+
+    it("should not reinitialize if already initialized", () => {
+      const commands = require("../commands");
+      
+      commands.init();
+      const logs1 = [...consoleMock.getLogs()];
+      consoleMock.clear();
+      
+      commands.init();
+      const logs2 = consoleMock.getLogs();
+      
+      expect(logs2.some(log => log.includes("already initialized"))).toBe(true);
+    });
+  });
+
+  describe("help", () => {
+    it("should display help information", () => {
+      const commands = require("../commands");
+      
+      commands.help();
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("SSH KeyMan");
+      expect(logs).toContain("Usage:");
+      expect(logs).toContain("Commands:");
+    });
+  });
+
+  describe("version", () => {
+    it("should display version information", () => {
+      const commands = require("../commands");
+      
+      commands.version();
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("ssh-keyman");
+      expect(logs).toContain("version");
+    });
+  });
+
+  describe("list", () => {
+    it("should show error when not initialized", () => {
+      const commands = require("../commands");
+      
+      commands.list();
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("not initialized");
+    });
+
+    it("should list available environments when initialized", () => {
+      const commands = require("../commands");
+      
+      commands.init();
+      
+      // Reload module to pick up new keyman content
+      jest.resetModules();
+      const commandsReloaded = require("../commands");
+      consoleMock.clear();
+      
+      commandsReloaded.list();
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("Available environments");
+      expect(logs).toContain("default");
+      expect(logs).toContain("active");
+    });
+  });
+
+  describe("create", () => {
+    it("should show error when not initialized", async () => {
+      const commands = require("../commands");
+      
+      await commands.create("test-env");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("not initialized");
+    });
+
+    it("should create new environment with name provided", async () => {
+      let inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload to pick up initialized state
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+      const commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.create("production");
+
+      expect(fs.existsSync(path.join(KEYMAN_DIR_PATH, "production"))).toBe(true);
+      
+      const keymanContent = JSON.parse(fs.readFileSync(KEYMAN_PATH, "utf8"));
+      expect(keymanContent.available).toContain("production");
+    });
+
+    it("should prompt for name when not provided", async () => {
+      let inquirer = require("inquirer");
+      let callCount = 0;
+      inquirer.prompt = jest.fn((questions) => {
+        callCount++;
+        const firstQuestion = questions[0];
+        if (firstQuestion.name === "envName") {
+          return Promise.resolve({ envName: "prompted-env" });
+        }
+        return Promise.resolve({ switchNow: false });
+      });
+
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload to pick up initialized state
+      jest.resetModules();
+      inquirer = require("inquirer");
+      callCount = 0;
+      inquirer.prompt = jest.fn((questions) => {
+        callCount++;
+        const firstQuestion = questions[0];
+        if (firstQuestion.name === "envName") {
+          return Promise.resolve({ envName: "prompted-env" });
+        }
+        return Promise.resolve({ switchNow: false });
+      });
+      const commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.create();
+
+      expect(callCount).toBeGreaterThan(0);
+      expect(fs.existsSync(path.join(KEYMAN_DIR_PATH, "prompted-env"))).toBe(true);
+    });
+  });
+
+  describe("switch", () => {
+    it("should show error when not initialized", async () => {
+      const commands = require("../commands");
+      
+      await commands.switch("production");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("not initialized");
+    });
+
+    it("should switch to existing environment", async () => {
+      let inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload to get initialized state
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+      let commandsReloaded = require("../commands");
+      await commandsReloaded.create("production");
+      
+      // Reload again to get updated environment list
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+      commandsReloaded = require("../commands");
+      consoleMock.clear();
+      
+      await commandsReloaded.switch("production");
+
+      const keymanContent = JSON.parse(fs.readFileSync(KEYMAN_PATH, "utf8"));
+      expect(keymanContent.active).toBe("production");
+    });
+
+    it("should show warning when already on selected environment", async () => {
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload to pick up initialized state
+      jest.resetModules();
+      const commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.switch("default");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("already");
+    });
+  });
+
+  describe("delete", () => {
+    it("should show error when not initialized", async () => {
+      const commands = require("../commands");
+      
+      await commands.delete("test-env");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("not initialized");
+    });
+
+    it("should not delete default environment", async () => {
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload to get initialized state
+      jest.resetModules();
+      const commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.delete("default");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("Default environment cannot be deleted");
+    });
+
+    it("should not delete active environment", async () => {
+      let inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: true })
+      );
+
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload and create new env
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: true })
+      );
+      let commandsReloaded = require("../commands");
+      await commandsReloaded.create("production");
+      
+      // Reload to get updated content
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: true })
+      );
+      commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.delete("production");
+
+      const logs = consoleMock.getLogs().join("\n");
+      expect(logs).toContain("currently active");
+    });
+
+    it("should delete non-active environment", async () => {
+      let inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+
+      const commands = require("../commands");
+      commands.init();
+      
+      // Reload and create new env
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+      let commandsReloaded = require("../commands");
+      await commandsReloaded.create("production");
+      
+      // Reload to get updated content
+      jest.resetModules();
+      inquirer = require("inquirer");
+      inquirer.prompt = jest.fn(() => 
+        Promise.resolve({ switchNow: false })
+      );
+      commandsReloaded = require("../commands");
+      consoleMock.clear();
+
+      await commandsReloaded.delete("production");
+
+      expect(fs.existsSync(path.join(KEYMAN_DIR_PATH, "production"))).toBe(false);
+      
+      const keymanContent = JSON.parse(fs.readFileSync(KEYMAN_PATH, "utf8"));
+      expect(keymanContent.available).not.toContain("production");
+    });
+  });
+});
+

package/src/__tests__/constants.test.js

@@ -0,0 +1,44 @@
+const { cliOptions, options } = require("../constants");
+
+describe("constants", () => {
+  describe("cliOptions", () => {
+    it("should be an array of CLI option definitions", () => {
+      expect(Array.isArray(cliOptions)).toBe(true);
+      expect(cliOptions.length).toBeGreaterThan(0);
+    });
+
+    it("should have correct structure for each option", () => {
+      cliOptions.forEach((option) => {
+        expect(Array.isArray(option)).toBe(true);
+        expect(option.length).toBe(3);
+        expect(typeof option[0]).toBe("string"); // short option
+        expect(typeof option[1]).toBe("string"); // long option name
+        expect(typeof option[2]).toBe("string"); // help text
+      });
+    });
+
+    it("should include all required commands", () => {
+      const commands = cliOptions.map((opt) => opt[0]);
+      expect(commands).toContain("i"); // init
+      expect(commands).toContain("c"); // create
+      expect(commands).toContain("s"); // switch
+      expect(commands).toContain("d"); // delete
+      expect(commands).toContain("ls"); // list
+      expect(commands).toContain("h"); // help
+      expect(commands).toContain("v"); // version
+    });
+
+    it("should have unique option names", () => {
+      const shortNames = cliOptions.map((opt) => opt[0]);
+      const uniqueNames = new Set(shortNames);
+      expect(uniqueNames.size).toBe(shortNames.length);
+    });
+  });
+
+  describe("options", () => {
+    it("should be an array", () => {
+      expect(Array.isArray(options)).toBe(true);
+    });
+  });
+});
+

package/src/__tests__/extendFs.test.js

@@ -0,0 +1,105 @@
+const fs = require("fs-extra");
+const path = require("path");
+const os = require("os");
+const { delDirSync, delAndCopySync } = require("../extendFs");
+
+describe("extendFs", () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = path.join(os.tmpdir(), `ssh-keyman-test-${Date.now()}`);
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("delDirSync", () => {
+    it("should delete an empty directory", () => {
+      const emptyDir = path.join(testDir, "empty");
+      fs.mkdirSync(emptyDir);
+
+      delDirSync(emptyDir);
+
+      expect(fs.existsSync(emptyDir)).toBe(false);
+    });
+
+    it("should delete a directory with files", () => {
+      const dirWithFiles = path.join(testDir, "withFiles");
+      fs.mkdirSync(dirWithFiles);
+      fs.writeFileSync(path.join(dirWithFiles, "file1.txt"), "content1");
+      fs.writeFileSync(path.join(dirWithFiles, "file2.txt"), "content2");
+
+      delDirSync(dirWithFiles);
+
+      expect(fs.existsSync(dirWithFiles)).toBe(false);
+    });
+
+    it("should delete a directory with nested directories", () => {
+      const dirWithNested = path.join(testDir, "withNested");
+      const nestedDir = path.join(dirWithNested, "nested");
+      fs.mkdirSync(nestedDir, { recursive: true });
+      fs.writeFileSync(path.join(nestedDir, "file.txt"), "content");
+
+      delDirSync(dirWithNested);
+
+      expect(fs.existsSync(dirWithNested)).toBe(false);
+    });
+  });
+
+  describe("delAndCopySync", () => {
+    it("should delete target directory and copy from source", () => {
+      const sourceDir = path.join(testDir, "source");
+      const targetDir = path.join(testDir, "target");
+
+      // Create source directory with files
+      fs.mkdirSync(sourceDir);
+      fs.writeFileSync(path.join(sourceDir, "file1.txt"), "source content 1");
+      fs.writeFileSync(path.join(sourceDir, "file2.txt"), "source content 2");
+
+      // Create target directory with different files
+      fs.mkdirSync(targetDir);
+      fs.writeFileSync(path.join(targetDir, "oldfile.txt"), "old content");
+
+      delAndCopySync(sourceDir, targetDir);
+
+      // Check that target exists
+      expect(fs.existsSync(targetDir)).toBe(true);
+      
+      // Check that source files were copied
+      expect(fs.existsSync(path.join(targetDir, "file1.txt"))).toBe(true);
+      expect(fs.existsSync(path.join(targetDir, "file2.txt"))).toBe(true);
+      expect(fs.readFileSync(path.join(targetDir, "file1.txt"), "utf8")).toBe(
+        "source content 1"
+      );
+      
+      // Check that old target file is gone
+      expect(fs.existsSync(path.join(targetDir, "oldfile.txt"))).toBe(false);
+    });
+
+    it("should handle nested directories in copy", () => {
+      const sourceDir = path.join(testDir, "source");
+      const targetDir = path.join(testDir, "target");
+      const nestedSource = path.join(sourceDir, "nested");
+
+      // Create source with nested structure
+      fs.mkdirSync(nestedSource, { recursive: true });
+      fs.writeFileSync(path.join(nestedSource, "nested.txt"), "nested content");
+
+      // Create empty target
+      fs.mkdirSync(targetDir);
+
+      delAndCopySync(sourceDir, targetDir);
+
+      // Check nested structure was copied
+      expect(fs.existsSync(path.join(targetDir, "nested", "nested.txt"))).toBe(true);
+      expect(
+        fs.readFileSync(path.join(targetDir, "nested", "nested.txt"), "utf8")
+      ).toBe("nested content");
+    });
+  });
+});
+

package/src/__tests__/helpers.js

@@ -0,0 +1,113 @@
+const fs = require("fs-extra");
+const path = require("path");
+const os = require("os");
+
+/**
+ * Create a mock file system structure for testing
+ */
+function createMockFileSystem(baseDir) {
+  const sshPath = path.join(baseDir, ".ssh");
+  const keymanPath = path.join(baseDir, ".sshkeyman");
+  const keymanFile = path.join(keymanPath, ".sshkeyman");
+  const defaultEnvPath = path.join(keymanPath, "default");
+
+  return {
+    sshPath,
+    keymanPath,
+    keymanFile,
+    defaultEnvPath,
+    setup: () => {
+      if (!fs.existsSync(baseDir)) {
+        fs.mkdirSync(baseDir, { recursive: true });
+      }
+      if (!fs.existsSync(sshPath)) {
+        fs.mkdirSync(sshPath, { recursive: true });
+        fs.writeFileSync(path.join(sshPath, "id_rsa"), "mock private key");
+        fs.writeFileSync(path.join(sshPath, "id_rsa.pub"), "mock public key");
+      }
+    },
+    cleanup: () => {
+      if (fs.existsSync(baseDir)) {
+        fs.rmSync(baseDir, { recursive: true, force: true });
+      }
+    },
+    initializeKeyman: () => {
+      if (!fs.existsSync(keymanPath)) {
+        fs.mkdirSync(keymanPath, { recursive: true });
+      }
+      if (!fs.existsSync(defaultEnvPath)) {
+        fs.mkdirSync(defaultEnvPath, { recursive: true });
+        fs.copySync(sshPath, defaultEnvPath);
+      }
+      fs.writeFileSync(
+        keymanFile,
+        JSON.stringify({ active: "default", available: ["default"] })
+      );
+    },
+  };
+}
+
+/**
+ * Mock console methods
+ */
+function mockConsole() {
+  const originalLog = console.log;
+  const originalError = console.error;
+  const logs = [];
+  const errors = [];
+
+  console.log = (...args) => {
+    logs.push(args.join(" "));
+  };
+  console.error = (...args) => {
+    errors.push(args.join(" "));
+  };
+
+  return {
+    logs,
+    errors,
+    restore: () => {
+      console.log = originalLog;
+      console.error = originalError;
+    },
+    getLogs: () => logs,
+    getErrors: () => errors,
+    clear: () => {
+      logs.length = 0;
+      errors.length = 0;
+    },
+  };
+}
+
+/**
+ * Mock inquirer prompts
+ */
+function mockInquirer(answers = {}) {
+  const inquirer = require("inquirer");
+  const originalPrompt = inquirer.prompt;
+
+  inquirer.prompt = jest.fn((questions) => {
+    const responses = {};
+    questions.forEach((q) => {
+      if (answers[q.name] !== undefined) {
+        responses[q.name] = answers[q.name];
+      } else if (q.default !== undefined) {
+        responses[q.name] = q.default;
+      }
+    });
+    return Promise.resolve(responses);
+  });
+
+  return {
+    restore: () => {
+      inquirer.prompt = originalPrompt;
+    },
+  };
+}
+
+module.exports = {
+  createMockFileSystem,
+  mockConsole,
+  mockInquirer,
+};
+