genlayer 0.34.0 → 0.34.3

package/tests/libs/keychainManager.test.ts

@@ -1,156 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
-import {KeychainManager} from "../../src/lib/config/KeychainManager";
-import keytar from "keytar";
-
-vi.mock("keytar");
-
-describe("KeychainManager", () => {
-  let keychainManager: KeychainManager;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    keychainManager = new KeychainManager();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("isKeychainAvailable", () => {
-    test("returns true when keychain is available", async () => {
-      vi.mocked(keytar.findCredentials).mockResolvedValue([]);
-
-      const result = await keychainManager.isKeychainAvailable();
-
-      expect(result).toBe(true);
-      expect(keytar.findCredentials).toHaveBeenCalledWith("test-service");
-    });
-
-    test("returns false when keychain is not available", async () => {
-      vi.mocked(keytar.findCredentials).mockRejectedValue(new Error("Keychain not available"));
-
-      const result = await keychainManager.isKeychainAvailable();
-
-      expect(result).toBe(false);
-      expect(keytar.findCredentials).toHaveBeenCalledWith("test-service");
-    });
-  });
-
-  describe("storePrivateKey", () => {
-    test("successfully stores private key", async () => {
-      const privateKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
-      vi.mocked(keytar.setPassword).mockResolvedValue();
-
-      await keychainManager.storePrivateKey("main", privateKey);
-
-      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "account:main", privateKey);
-    });
-
-    test("handles storage error", async () => {
-      const privateKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
-      vi.mocked(keytar.setPassword).mockRejectedValue(new Error("Storage failed"));
-
-      await expect(keychainManager.storePrivateKey("main", privateKey)).rejects.toThrow("Storage failed");
-      expect(keytar.setPassword).toHaveBeenCalledWith("genlayer-cli", "account:main", privateKey);
-    });
-  });
-
-  describe("getPrivateKey", () => {
-    test("returns private key when it exists", async () => {
-      const expectedKey = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
-      vi.mocked(keytar.getPassword).mockResolvedValue(expectedKey);
-
-      const result = await keychainManager.getPrivateKey("main");
-
-      expect(result).toBe(expectedKey);
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-
-    test("returns null when private key does not exist", async () => {
-      vi.mocked(keytar.getPassword).mockResolvedValue(null);
-
-      const result = await keychainManager.getPrivateKey("main");
-
-      expect(result).toBeNull();
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-
-    test("returns null on retrieval error", async () => {
-      vi.mocked(keytar.getPassword).mockRejectedValue(new Error("Retrieval failed"));
-
-      const result = await keychainManager.getPrivateKey("main");
-
-      expect(result).toBeNull();
-      expect(keytar.getPassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-  });
-
-  describe("removePrivateKey", () => {
-    test("successfully removes private key", async () => {
-      vi.mocked(keytar.deletePassword).mockResolvedValue(true);
-
-      const result = await keychainManager.removePrivateKey("main");
-
-      expect(result).toBe(true);
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-
-    test("returns false when key does not exist", async () => {
-      vi.mocked(keytar.deletePassword).mockResolvedValue(false);
-
-      const result = await keychainManager.removePrivateKey("main");
-
-      expect(result).toBe(false);
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-
-    test("returns false on removal error", async () => {
-      vi.mocked(keytar.deletePassword).mockRejectedValue(new Error("Removal failed"));
-
-      const result = await keychainManager.removePrivateKey("main");
-
-      expect(result).toBe(false);
-      expect(keytar.deletePassword).toHaveBeenCalledWith("genlayer-cli", "account:main");
-    });
-  });
-
-  describe("listUnlockedAccounts", () => {
-    test("returns list of unlocked account names", async () => {
-      vi.mocked(keytar.findCredentials).mockResolvedValue([
-        {account: "account:main", password: "key1"},
-        {account: "account:validator", password: "key2"},
-        {account: "other:something", password: "key3"},
-      ]);
-
-      const result = await keychainManager.listUnlockedAccounts();
-
-      expect(result).toEqual(["main", "validator"]);
-    });
-
-    test("returns empty array when no accounts", async () => {
-      vi.mocked(keytar.findCredentials).mockResolvedValue([]);
-
-      const result = await keychainManager.listUnlockedAccounts();
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe("isAccountUnlocked", () => {
-    test("returns true when account is unlocked", async () => {
-      vi.mocked(keytar.getPassword).mockResolvedValue("some-key");
-
-      const result = await keychainManager.isAccountUnlocked("main");
-
-      expect(result).toBe(true);
-    });
-
-    test("returns false when account is locked", async () => {
-      vi.mocked(keytar.getPassword).mockResolvedValue(null);
-
-      const result = await keychainManager.isAccountUnlocked("main");
-
-      expect(result).toBe(false);
-    });
-  });
-}); 

package/tests/libs/system.test.ts

@@ -1,148 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from "vitest";
-import util from "node:util";
-import {
-  checkCommand,
-  executeCommand,
-  openUrl,
-  getVersion
-} from "../../src/lib/clients/system";
-import { MissingRequirementError } from "../../src/lib/errors/missingRequirement";
-import open from "open";
-
-vi.mock("open");
-vi.mock("util");
-
-describe("System Functions - Success Paths", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test("openUrl opens URL successfully", async () => {
-    const openSpy = vi.mocked(open).mockResolvedValue({} as any);
-    const url = "https://example.com";
-    await openUrl(url);
-    expect(openSpy).toHaveBeenCalledWith(url);
-  });
-
-  test("getVersion retrieves tool version", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
-      stdout: "git v1.2.3",
-      stderr: ""
-    }));
-    const version = await getVersion("git");
-    expect(version).toBe("1.2.3");
-  });
-
-  test("checkCommand verifies a command exists", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({ stdout: "", stderr: "" }));
-    const result = await checkCommand("node --version", "node");
-    expect(result).toBe(undefined);
-  });
-
-  test("executeCommand executes a command successfully", async () => {
-    const platformSpy = vi.spyOn(process, "platform", "get").mockReturnValue("linux");
-    vi.mocked(util.promisify).mockReturnValueOnce((param: string) => Promise.resolve({
-      stdout: param,
-      stderr: ""
-    }));
-    const result = await executeCommand({
-        linux: "echo linux",
-        win32: "echo win32",
-        darwin: "echo darwin",
-      },
-      "echo");
-    expect(result.stdout).toBe("echo linux");
-    platformSpy.mockRestore();
-  });
-});
-
-describe("System Functions - Error Paths", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test("getVersion throws an error if the command fails", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
-      stdout: "",
-      stderr: "command not found"
-    }));
-    const toolName = "nonexistent";
-    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
-  });
-
-  test("getVersion returns '' if stdout is empty", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
-      stdout: "",
-      stderr: ""
-    }));
-    const result = await getVersion('git');
-    expect(result).toBe("");
-  });
-
-  test("getVersion throw error if stdout undefined", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
-      stderr: ""
-    }));
-    const toolName = "nonexistent";
-    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
-  });
-
-  test("checkCommand returns false if the command does not exist", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject({
-      stdout: "",
-      stderr: "command not found"
-    }));
-    const toolName = 'nonexistent';
-    await expect(checkCommand(`${toolName} --version`, toolName)).rejects.toThrow(new MissingRequirementError(toolName));
-  });
-
-  test("executeCommand throws an error if the command fails", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution failed")));
-    await expect(executeCommand({
-        linux: "echo hello",
-        win32: "echo hello",
-        darwin: "echo hello",
-      },
-      "echo")).rejects.toThrow("Execution failed");
-  });
-
-  test("throws error when command execution fails", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
-    await expect(executeCommand({
-      linux: "echo no toolname",
-      win32: "echo no toolname",
-      darwin: "echo no toolname",
-    })).rejects.toThrow(
-      "Error executing echo no toolname: Execution error."
-    );
-  });
-
-  test("throws error when command execution fails (toolname)", async () => {
-    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
-    await expect(executeCommand({
-        linux: "echo linux",
-        win32: "echo win32",
-        darwin: "echo darwin",
-      },
-      "echo")).rejects.toThrow(
-      "Error executing echo: Execution error."
-    );
-  });
-
-  test("throws an error for unsupported platform in executeCommand", () => {
-    const unsupportedPlatform = "unsupportedOS";
-    const originalPlatform = process.platform;
-    Object.defineProperty(process, "platform", {
-      value: unsupportedPlatform,
-    });
-    const cmdsByPlatform = {
-      linux: "echo Linux",
-      darwin: "echo macOS",
-      win32: "echo Windows",
-    };
-    expect(executeCommand(cmdsByPlatform)).rejects.toThrow(
-      `Unsupported platform: ${unsupportedPlatform}.`
-    );
-    Object.defineProperty(process, "platform", { value: originalPlatform });
-  });
-});