genlayer 0.33.1 → 0.34.1

package/tests/libs/baseAction.test.ts

@@ -1,516 +0,0 @@
-import {describe, test, vi, beforeEach, afterEach, expect, Mock} from "vitest";
-import {BaseAction} from "../../src/lib/actions/BaseAction";
-import inquirer from "inquirer";
-import ora, {Ora} from "ora";
-import chalk from "chalk";
-import {inspect} from "util";
-import { ethers } from "ethers";
-import { writeFileSync, existsSync, readFileSync } from "fs";
-import fs from "fs";
-import os from "os";
-import { createAccount } from "genlayer-js";
-
-vi.mock("inquirer");
-vi.mock("ora");
-vi.mock("fs");
-vi.mock("os");
-vi.mock("ethers");
-vi.mock("genlayer-js", () => ({
-  createAccount: vi.fn(),
-  createClient: vi.fn(),
-  localnet: {}
-}));
-
-describe("BaseAction", () => {
-  let baseAction: BaseAction;
-  let mockSpinner: Ora;
-  let consoleSpy: any;
-  let consoleErrorSpy: any;
-  let processExitSpy: any;
-
-  // Standard web3 keystore format
-  const mockKeystoreData = {
-    address: "1234567890123456789012345678901234567890",
-    crypto: {
-      cipher: "aes-128-ctr",
-      ciphertext: "test",
-      cipherparams: {iv: "test"},
-      kdf: "scrypt",
-      kdfparams: {},
-      mac: "test"
-    },
-    version: 3
-  };
-
-  const mockWallet = {
-    privateKey: "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
-    address: "0x1234567890123456789012345678901234567890",
-    encrypt: vi.fn().mockResolvedValue('{"address":"test","crypto":{"cipher":"aes-128-ctr"}}'),
-  };
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process exited");
-    });
-    mockSpinner = {
-      start: vi.fn(),
-      stop: vi.fn(),
-      succeed: vi.fn(),
-      fail: vi.fn(),
-      text: "",
-    } as unknown as Ora;
-
-    (ora as unknown as Mock).mockReturnValue(mockSpinner);
-    
-    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
-    vi.mocked(os.tmpdir).mockReturnValue("/mocked/tmp");
-    
-    vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(readFileSync).mockReturnValue(JSON.stringify(mockKeystoreData));
-    vi.mocked(writeFileSync).mockImplementation(() => {});
-    vi.mocked(fs.readdirSync).mockReturnValue([] as any);
-    vi.mocked(fs.mkdirSync).mockImplementation(() => "/mocked/path");
-
-    // Mock ethers
-    vi.mocked(ethers.Wallet.createRandom).mockReturnValue(mockWallet as any);
-    vi.mocked(ethers.Wallet.fromEncryptedJson).mockResolvedValue(mockWallet as any);
-
-    vi.mocked(createAccount).mockReturnValue({
-      privateKey: mockWallet.privateKey,
-      address: mockWallet.address
-    } as any);
-
-    baseAction = new BaseAction();
-
-    // Mock config methods
-    vi.spyOn(baseAction as any, "getConfigByKey").mockReturnValue("./test-keypair.json");
-    vi.spyOn(baseAction as any, "getFilePath").mockImplementation(() => "./test-keypair.json");
-    vi.spyOn(baseAction as any, "writeConfig").mockImplementation(() => {});
-    vi.spyOn(baseAction as any, "getConfig").mockReturnValue({activeAccount: "default"});
-    vi.spyOn(baseAction as any, "resolveAccountName").mockReturnValue("default");
-    vi.spyOn(baseAction as any, "getKeystorePath").mockReturnValue("/mocked/home/.genlayer/keystores/default.json");
-    vi.spyOn(baseAction as any, "getActiveAccount").mockReturnValue("default");
-
-    // Mock keychainManager methods
-    vi.spyOn(baseAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(false);
-    vi.spyOn(baseAction["keychainManager"], "getPrivateKey").mockResolvedValue(null);
-    vi.spyOn(baseAction["keychainManager"], "storePrivateKey").mockResolvedValue();
-    vi.spyOn(baseAction["keychainManager"], "removePrivateKey").mockResolvedValue(true);
-
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("should start the spinner with a message", () => {
-    baseAction["startSpinner"]("Loading...");
-    expect(mockSpinner.start).toHaveBeenCalled();
-    expect(mockSpinner.text).toBe(chalk.blue("Loading..."));
-  });
-
-  test("should succeed the spinner with a message", () => {
-    baseAction["succeedSpinner"]("Success");
-    expect(consoleSpy).toHaveBeenCalledWith("");
-    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
-  });
-
-  test("should fail the spinner with an error message", () => {
-    const error = new Error("Something went wrong");
-    baseAction["failSpinner"]("Failure", error, false); // Don't exit for test
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Error:"));
-    expect(consoleSpy).toHaveBeenCalledWith(inspect(error, {depth: null, colors: false}));
-    expect(consoleSpy).toHaveBeenCalledWith("");
-    expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failure"));
-  });
-
-  test("should fail the spinner and exit by default", () => {
-    const error = new Error("Fatal error");
-    expect(() => baseAction["failSpinner"]("Fatal", error)).toThrow("process exited");
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test("should stop the spinner", () => {
-    baseAction["stopSpinner"]();
-    expect(mockSpinner.stop).toHaveBeenCalled();
-  });
-
-  test("should set spinner text", () => {
-    baseAction["setSpinnerText"]("Updated text");
-    expect(mockSpinner.text).toBe(chalk.blue("Updated text"));
-  });
-
-  test("should confirm prompt and proceed when confirmed", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: true});
-
-    await expect(baseAction["confirmPrompt"]("Are you sure?")).resolves.not.toThrow();
-    expect(inquirer.prompt).toHaveBeenCalled();
-  });
-
-  test("should confirm prompt and exit when declined", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
-    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
-      throw new Error("process exited");
-    });
-
-    await expect(baseAction["confirmPrompt"]("Are you sure?")).rejects.toThrow("process exited");
-    expect(inquirer.prompt).toHaveBeenCalled();
-    expect(processExitSpy).toHaveBeenCalledWith(0);
-  });
-
-  test("should log a success message", () => {
-    baseAction["logSuccess"]("Success message");
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
-  });
-
-  test("should log an error message", () => {
-    baseAction["logError"]("Error message");
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
-  });
-
-  test("should log a info message", () => {
-    baseAction["logInfo"]("Info message");
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
-  });
-
-  test("should log a warning message", () => {
-    baseAction["logWarning"]("Warning message");
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
-  });
-
-  test("should log a success message with data", () => {
-    const data = {key: "value"};
-
-    baseAction["logSuccess"]("Success message", data);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
-    expect(consoleSpy).toHaveBeenCalledWith(chalk.green(inspect(data, {depth: null, colors: false})));
-  });
-
-  test("should log an error message with error details", () => {
-    const error = new Error("Something went wrong");
-
-    baseAction["logError"]("Error message", error);
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
-    expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red(inspect(error, {depth: null, colors: false})));
-  });
-
-  test("should log an info message with data", () => {
-    const data = {info: "This is some info"};
-
-    baseAction["logInfo"]("Info message", data);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
-    expect(consoleSpy).toHaveBeenCalledWith(chalk.blue(inspect(data, {depth: null, colors: false})));
-  });
-
-  test("should log a warning message with data", () => {
-    const data = {warning: "This is a warning"};
-
-    baseAction["logWarning"]("Warning message", data);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
-    expect(consoleSpy).toHaveBeenCalledWith(chalk.yellow(inspect(data, {depth: null, colors: false})));
-  });
-
-  test("should succeed the spinner with a message and log result if data is provided", () => {
-    const mockData = {key: "value"};
-
-    baseAction["succeedSpinner"]("Success", mockData);
-
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Result:"));
-    expect(consoleSpy).toHaveBeenCalledWith(inspect(mockData, {depth: null, colors: false}));
-    expect(consoleSpy).toHaveBeenCalledWith("");
-    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
-  });
-
-  test("should return a string representation of a primitive", () => {
-    expect((baseAction as any).formatOutput("Hello")).toBe("Hello");
-    expect((baseAction as any).formatOutput(42)).toBe("42");
-    expect((baseAction as any).formatOutput(true)).toBe("true");
-  });
-
-  test("should prompt for password successfully", async () => {
-    const mockPassword = "test-password";
-    vi.mocked(inquirer.prompt).mockResolvedValue({password: mockPassword});
-
-    const result = await baseAction["promptPassword"]("Enter password:");
-    
-    expect(result).toBe(mockPassword);
-    expect(inquirer.prompt).toHaveBeenCalledWith([{
-      type: "password",
-      name: "password",
-      message: chalk.yellow("Enter password:"),
-      mask: "*",
-      validate: expect.any(Function),
-    }]);
-  });
-
-  test("should validate password input is not empty", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({password: "valid-password"});
-
-    await baseAction["promptPassword"]("Enter password:");
-    
-    const mockCall = vi.mocked(inquirer.prompt).mock.calls[0];
-    const questions = mockCall[0] as any;
-    const validateFn = questions[0].validate;
-    expect(validateFn("")).toBe("Password cannot be empty");
-    expect(validateFn("valid")).toBe(true);
-  });
-
-  test("should return private key when keystore exists and is valid", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
-
-    const account = await baseAction["getAccount"](false);
-
-    expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
-    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
-  });
-
-  test("should return address when called with readOnly=true", async () => {
-    const address = await baseAction["getAccount"](true);
-
-    expect(address).toBe(mockKeystoreData.address);
-    expect(existsSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json");
-    expect(readFileSync).toHaveBeenCalledWith("/mocked/home/.genlayer/keystores/default.json", "utf-8");
-  });
-
-  test("should create new keypair when keystore file does not exist", async () => {
-    vi.mocked(existsSync).mockReturnValue(false);
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({confirmAction: true}) // confirm create new
-      .mockResolvedValueOnce({password: "new-password"}) // encrypt password
-      .mockResolvedValueOnce({password: "new-password"}); // confirm password
-
-    const account = await baseAction["getAccount"](false);
-
-    expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({message: chalk.yellow("Account 'default' not found. Would you like to create it?")})
-    ]));
-  });
-
-  test("should fail when keystore format is invalid and user declines", async () => {
-    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
-    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
-
-    await expect(baseAction["getAccount"](false)).rejects.toThrow("process exited");
-    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
-  });
-
-  test("should use cached key when available", async () => {
-    vi.spyOn(baseAction["keychainManager"], "isKeychainAvailable").mockResolvedValue(true);
-    vi.spyOn(baseAction["keychainManager"], "getPrivateKey").mockResolvedValue(mockWallet.privateKey);
-
-    const account = await baseAction["getAccount"](false);
-
-    expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(baseAction["keychainManager"].getPrivateKey).toHaveBeenCalledWith("default");
-    expect(inquirer.prompt).not.toHaveBeenCalled();
-  });
-
-  test("should create new keypair when keystore format is invalid and user confirms", async () => {
-    vi.mocked(readFileSync).mockReturnValue('{"invalid": "format"}');
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({confirmAction: true})
-      .mockResolvedValueOnce({password: "new-password"})
-      .mockResolvedValueOnce({password: "new-password"});
-
-    const account = await baseAction["getAccount"](false);
-
-    expect((account as any).privateKey).toBe(mockWallet.privateKey);
-    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Invalid keystore format. Expected encrypted keystore file."));
-    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({message: "Would you like to recreate account 'default'?"})
-    ]));
-  });
-
-  test("should decrypt keystore successfully on first attempt", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({password: "correct-password"});
-
-    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
-
-    expect(result).toBe(mockWallet.privateKey);
-    expect(inquirer.prompt).toHaveBeenCalledWith(expect.arrayContaining([
-      expect.objectContaining({message: chalk.yellow("Enter password to decrypt keystore:")})
-    ]));
-  });
-
-  test("should retry on wrong password and succeed on second attempt", async () => {
-    vi.mocked(ethers.Wallet.fromEncryptedJson)
-      .mockRejectedValueOnce(new Error("Incorrect password"))
-      .mockResolvedValueOnce(mockWallet as any);
-
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({password: "wrong-password"})
-      .mockResolvedValueOnce({password: "correct-password"});
-
-    const result = await baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData));
-
-    expect(result).toBe(mockWallet.privateKey);
-    expect(inquirer.prompt).toHaveBeenCalledTimes(2);
-    expect(inquirer.prompt).toHaveBeenNthCalledWith(2, expect.arrayContaining([
-      expect.objectContaining({message: chalk.yellow("Invalid password. Attempt 2/3 - Enter password to decrypt keystore:")})
-    ]));
-  });
-
-  test("should exit after 3 failed password attempts", async () => {
-    vi.mocked(ethers.Wallet.fromEncryptedJson).mockRejectedValue(new Error("Incorrect password"));
-    vi.mocked(inquirer.prompt).mockResolvedValue({password: "wrong-password"});
-
-    await expect(baseAction["decryptKeystore"](JSON.stringify(mockKeystoreData))).rejects.toThrow("process exited");
-
-    expect(inquirer.prompt).toHaveBeenCalledTimes(3);
-    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Maximum password attempts exceeded (3/3)."));
-    expect(processExitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test("should create new keypair successfully", async () => {
-    vi.mocked(existsSync).mockReturnValue(false);
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({password: "test-password"})
-      .mockResolvedValueOnce({password: "test-password"});
-
-    const result = await baseAction["createKeypairByName"]("test-account", false);
-
-    expect(result).toBe(mockWallet.privateKey);
-    expect(ethers.Wallet.createRandom).toHaveBeenCalled();
-    expect(mockWallet.encrypt).toHaveBeenCalledWith("test-password");
-    expect(writeFileSync).toHaveBeenCalled();
-    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
-  });
-
-  test("should fail when account exists and overwrite is false", async () => {
-    vi.mocked(existsSync).mockReturnValue(true);
-
-    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
-
-    expect(mockSpinner.fail).toHaveBeenCalledWith(
-      chalk.red("Account 'test-account' already exists. Use '--overwrite' to replace it.")
-    );
-  });
-
-  test("should fail when passwords do not match", async () => {
-    vi.mocked(existsSync).mockReturnValue(false);
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({password: "password1"})
-      .mockResolvedValueOnce({password: "password2"});
-
-    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
-
-    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Passwords do not match"));
-  });
-
-  test("should fail when password is too short", async () => {
-    vi.mocked(existsSync).mockReturnValue(false);
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({password: "short"})
-      .mockResolvedValueOnce({password: "short"});
-
-    await expect(baseAction["createKeypairByName"]("test-account", false)).rejects.toThrow("process exited");
-
-    expect(mockSpinner.fail).toHaveBeenCalledWith(chalk.red("Password must be at least 8 characters long"));
-  });
-
-  test("should overwrite existing account when overwrite is true", async () => {
-    vi.mocked(existsSync).mockReturnValue(true);
-    vi.mocked(inquirer.prompt)
-      .mockResolvedValueOnce({password: "test-password"})
-      .mockResolvedValueOnce({password: "test-password"});
-
-    const result = await baseAction["createKeypairByName"]("test-account", true);
-
-    expect(result).toBe(mockWallet.privateKey);
-    expect(writeFileSync).toHaveBeenCalled();
-    expect(baseAction["keychainManager"].removePrivateKey).toHaveBeenCalledWith("test-account");
-  });
-
-  test("should return true for valid keystore format", () => {
-    // Standard web3 keystore format
-    const validKeystore = {
-      address: "1234567890123456789012345678901234567890",
-      crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
-      version: 3,
-    };
-
-    const result = baseAction["isValidKeystoreFormat"](validKeystore);
-    expect(result).toBe(true);
-  });
-
-  test("should return true for keystore with uppercase Crypto field", () => {
-    // Some tools use uppercase 'Crypto'
-    const validKeystore = {
-      address: "1234567890123456789012345678901234567890",
-      Crypto: {cipher: "aes-128-ctr", ciphertext: "test"},
-      version: 3,
-    };
-
-    const result = baseAction["isValidKeystoreFormat"](validKeystore);
-    expect(result).toBe(true);
-  });
-
-  test("should return false for keystore missing crypto field", () => {
-    const invalidKeystore = {
-      address: "1234567890123456789012345678901234567890",
-      version: 3,
-    };
-
-    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
-    expect(result).toBe(false);
-  });
-
-  test("should return false for keystore missing address", () => {
-    const invalidKeystore = {
-      crypto: {cipher: "aes-128-ctr"},
-      version: 3,
-    };
-
-    const result = baseAction["isValidKeystoreFormat"](invalidKeystore);
-    expect(result).toBe(false);
-  });
-
-  test("should return false for null or undefined keystore", () => {
-    expect(baseAction["isValidKeystoreFormat"](null)).toBe(false);
-    expect(baseAction["isValidKeystoreFormat"](undefined)).toBe(false);
-  });
-
-  describe("formatOutput", () => {
-    test("should return string as is", () => {
-      expect((baseAction as any).formatOutput("Hello")).toBe("Hello");
-    });
-
-    test("should format an object", () => {
-      const data = {key: "value", num: 42};
-      const result = (baseAction as any).formatOutput(data);
-      expect(result).toBe("{ key: 'value', num: 42 }");
-    });
-
-    test("should format an error object", () => {
-      const error = new Error("Test Error");
-      const result = (baseAction as any).formatOutput(error);
-      expect(result).toContain("Error: Test Error");
-    });
-
-    test("should format a Map object", () => {
-      const testMap = new Map([["key1", "value1"]]);
-      const result = (baseAction as any).formatOutput(testMap);
-      expect(result).toBe("Map(1) { 'key1' => 'value1' }");
-    });
-
-    test("should format a BigInt object", () => {
-      const bigIntValue = BigInt(9007199254740991);
-      const result = (baseAction as any).formatOutput(bigIntValue);
-      expect(result).toBe("9007199254740991n");
-    });
-  });
-});

package/tests/libs/configFileManager.test.ts

@@ -1,117 +0,0 @@
-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 mockFolderPath = "/mocked/home/.genlayer";
-  const mockKeystoresPath = `${mockFolderPath}/keystores`;
-  const mockConfigFilePath = `${mockFolderPath}/genlayer-config.json`;
-
-  let configFileManager: ConfigFileManager;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(os.homedir).mockReturnValue("/mocked/home");
-    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

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