genlayer 0.38.9 → 0.38.10

package/tests/libs/configFileManager.test.ts

@@ -0,0 +1,118 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+vi.mock("fs");
+
+vi.mock("os")
+
+describe("ConfigFileManager", () => {
+  const mockHome = path.resolve("/mocked/home");
+  const mockFolderPath = path.resolve(mockHome, ".genlayer");
+  const mockKeystoresPath = path.resolve(mockFolderPath, "keystores");
+  const mockConfigFilePath = path.resolve(mockFolderPath, "genlayer-config.json");
+
+  let configFileManager: ConfigFileManager;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(os.homedir).mockReturnValue(mockHome);
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
+    configFileManager = new ConfigFileManager();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ensures folder and config file are created if they don't exist", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
+
+    new ConfigFileManager();
+
+    expect(fs.existsSync).toHaveBeenCalledWith(mockFolderPath);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockFolderPath, { recursive: true });
+
+    expect(fs.existsSync).toHaveBeenCalledWith(mockKeystoresPath);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(mockKeystoresPath, { recursive: true });
+
+    expect(fs.existsSync).toHaveBeenCalledWith(mockConfigFilePath);
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockConfigFilePath, JSON.stringify({}, null, 2));
+  });
+
+  test("does not recreate folder or config file if they exist", () => {
+    vi.clearAllMocks();
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({}));
+
+    new ConfigFileManager();
+
+    expect(fs.mkdirSync).not.toHaveBeenCalled();
+  });
+
+  test("getFolderPath returns the correct folder path", () => {
+    expect(configFileManager.getFolderPath()).toBe(mockFolderPath);
+  });
+
+  test("getFilePath returns the correct file path for a given file name", () => {
+    const fileName = "example.json";
+    const expectedFilePath = path.resolve(mockFolderPath, fileName);
+
+    expect(configFileManager.getFilePath(fileName)).toBe(expectedFilePath);
+  });
+
+  test("getConfig returns the parsed content of the config file", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const config = configFileManager.getConfig();
+
+    expect(fs.readFileSync).toHaveBeenCalledWith(mockConfigFilePath, "utf-8");
+    expect(config).toEqual(mockConfig);
+  });
+
+  test("getConfigByKey returns the value for a given key", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const value = configFileManager.getConfigByKey("key");
+
+    expect(value).toBe("value");
+  });
+
+  test("getConfigByKey returns null for a non-existing key", () => {
+    const mockConfig = { key: "value" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    const value = configFileManager.getConfigByKey("nonExistingKey");
+
+    expect(value).toBeNull();
+  });
+
+  test("writeConfig updates the config file with a new key-value pair", () => {
+    const mockConfig = { existingKey: "existingValue" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockConfig));
+
+    configFileManager.writeConfig("newKey", "newValue");
+
+    const expectedConfig = { existingKey: "existingValue", newKey: "newValue" };
+    expect(fs.writeFileSync).toHaveBeenCalledWith(
+      mockConfigFilePath,
+      JSON.stringify(expectedConfig, null, 2)
+    );
+  });
+
+  test("writeConfig overwrites an existing key in the config file", () => {
+    const existingConfig = { existingKey: "existingValue" };
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(existingConfig));
+
+    configFileManager.writeConfig("existingKey", "newValue");
+
+    const expectedConfig = { existingKey: "newValue" };
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockConfigFilePath, JSON.stringify(expectedConfig, null, 2));
+  });
+});

package/tests/libs/jsonRpcClient.test.ts

@@ -0,0 +1,59 @@
+import { describe, beforeEach, test, expect, vi, Mock } from "vitest";
+import fetch from "node-fetch";
+import { JsonRpcClient, JsonRPCParams } from "../../src/lib/clients/jsonRpcClient";
+
+vi.mock("node-fetch", () => ({
+  default: vi.fn(),
+}));
+
+describe("JsonRpcClient - Successful and Unsuccessful Requests", () => {
+  let rpcClient: JsonRpcClient;
+  const mockServerUrl = "http://mock-server-url.com";
+
+  beforeEach(() => {
+    rpcClient = new JsonRpcClient(mockServerUrl);
+  });
+
+  test("should make a successful JSON-RPC request and return the JSON response", async () => {
+    const mockResponse = { result: "success" };
+
+    (fetch as Mock).mockResolvedValueOnce({
+      ok: true,
+      json: async () => mockResponse,
+    });
+
+    const params: JsonRPCParams = {
+      method: "testMethod",
+      params: ["param1", "param2"],
+    };
+
+    const response = await rpcClient.request(params);
+
+    expect(fetch).toHaveBeenCalledWith(mockServerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: expect.stringContaining('"method":"testMethod"'),
+    });
+    expect(response).toEqual(mockResponse);
+  });
+
+  test("should return null when the fetch response is not ok", async () => {
+    (fetch as Mock).mockResolvedValueOnce({
+      ok: false,
+      statusText: "Something went wrong",
+      json: async () => ({ error: "Something went wrong" }),
+    });
+
+    const params: JsonRPCParams = {
+      method: "testMethod",
+      params: ["param1", "param2"],
+    };
+
+    await expect(rpcClient.request(params)).rejects.toThrowError("Something went wrong");
+    expect(fetch).toHaveBeenCalledWith(mockServerUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: expect.stringContaining('"method":"testMethod"'),
+    });
+  });
+});

package/tests/libs/keychainManager.test.ts

@@ -0,0 +1,156 @@
+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/platformCommands.test.ts

@@ -0,0 +1,78 @@
+import {describe, test, expect} from "vitest";
+import {DEFAULT_RUN_SIMULATOR_COMMAND} from "../../src/lib/config/simulator";
+
+describe("Platform-specific command generation", () => {
+  describe("DEFAULT_RUN_SIMULATOR_COMMAND", () => {
+    test("win32 command does not use start cmd.exe", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/some/path", "");
+      expect(cmds.win32).not.toContain("start cmd.exe");
+    });
+
+    test("win32 command quotes the path", () => {
+      const pathWithSpaces = "C:\\Program Files\\genlayer";
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND(pathWithSpaces, "");
+      expect(cmds.win32).toContain(`"${pathWithSpaces}"`);
+    });
+
+    test("win32 command uses -d flag for detached mode", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", "");
+      expect(cmds.win32).toContain("up -d");
+    });
+
+    test("win32 command uses cd /d for drive changes", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("D:\\projects\\genlayer", "");
+      expect(cmds.win32).toContain("cd /d");
+    });
+
+    test("linux command uses nohup with -d flag", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", "");
+      expect(cmds.linux).toContain("nohup");
+      expect(cmds.linux).toContain("up -d");
+    });
+
+    test("linux command quotes the path", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path with spaces", "");
+      expect(cmds.linux).toContain('"/path with spaces"');
+    });
+
+    test("darwin command uses osascript", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", "");
+      expect(cmds.darwin).toContain("osascript");
+    });
+
+    test("darwin command quotes the path for spaces", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path with spaces", "");
+      expect(cmds.darwin).toContain("/path with spaces");
+    });
+
+    test("all platforms include profiles when provided", () => {
+      const profiles = "--profile frontend --profile ollama";
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", profiles);
+      expect(cmds.darwin).toContain(profiles);
+      expect(cmds.win32).toContain(profiles);
+      expect(cmds.linux).toContain(profiles);
+    });
+
+    test("all platforms include docker compose build and up", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", "");
+      for (const platform of ["darwin", "win32", "linux"] as const) {
+        expect(cmds[platform]).toContain("docker compose build");
+        expect(cmds[platform]).toContain("docker compose -p genlayer");
+      }
+    });
+
+    test("all platforms handle empty profiles", () => {
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND("/path", "");
+      for (const platform of ["darwin", "win32", "linux"] as const) {
+        expect(cmds[platform]).toContain("docker compose -p genlayer  up");
+      }
+    });
+
+    test("paths with spaces are quoted on win32 and linux", () => {
+      const spacePath = "/some path/with spaces";
+      const cmds = DEFAULT_RUN_SIMULATOR_COMMAND(spacePath, "");
+      expect(cmds.win32).toContain(`"${spacePath}"`);
+      expect(cmds.linux).toContain(`"${spacePath}"`);
+    });
+  });
+});

package/tests/libs/system.test.ts

@@ -0,0 +1,148 @@
+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 });
+  });
+});