genlayer 0.18.0 → 0.18.2-beta.0

package/tests/actions/start.test.ts

@@ -1,7 +1,7 @@
-import { describe, beforeEach, afterEach, test, expect, vi, Mock } from "vitest";
+import {describe, beforeEach, afterEach, test, expect, vi, Mock} from "vitest";
 import inquirer from "inquirer";
-import { StartAction, StartActionOptions } from "../../src/commands/general/start";
-import { SimulatorService } from "../../src/lib/services/simulator";
+import {StartAction, StartActionOptions} from "../../src/commands/general/start";
+import {SimulatorService} from "../../src/lib/services/simulator";
 
 vi.mock("../../src/lib/services/simulator");
 vi.mock("inquirer");
@@ -18,7 +18,7 @@ describe("StartAction", () => {
     startAction = new StartAction();
     startAction["simulatorService"] = mockSimulatorService;
 
-    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({ initialized: true });
+    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({initialized: true});
     mockSimulatorService.stopDockerContainers = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.getAiProvidersOptions = vi.fn().mockResolvedValue(undefined);
 
@@ -43,9 +43,9 @@ describe("StartAction", () => {
 
   test("should check if localnet is running and proceed without confirmation when not running", async () => {
     mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(false);
-    
+
     await startAction.execute(defaultOptions);
-    
+
     expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
     expect(mockConfirmPrompt).not.toHaveBeenCalled();
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
@@ -53,11 +53,13 @@ describe("StartAction", () => {
 
   test("should prompt for confirmation when localnet is already running", async () => {
     mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(true);
-    
+
     await startAction.execute(defaultOptions);
-    
+
     expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
-    expect(mockConfirmPrompt).toHaveBeenCalledWith("GenLayer Localnet is already running. Do you want to proceed?");
+    expect(mockConfirmPrompt).toHaveBeenCalledWith(
+      "GenLayer Localnet is already running. Do you want to proceed?",
+    );
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
   });
 
@@ -71,13 +73,17 @@ describe("StartAction", () => {
     expect(startAction["startSpinner"]).toHaveBeenCalledWith("Checking CLI version...");
     expect(mockSimulatorService.checkCliVersion).toHaveBeenCalled();
 
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Starting GenLayer Localnet (keeping the existing validators)...");
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith(
+      "Starting GenLayer Localnet (keeping the existing validators)...",
+    );
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
 
     expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Waiting for the simulator to be ready...");
     expect(mockSimulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
 
-    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith("GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.");
+    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.",
+    );
   });
 
   test("should fail when simulator fails to start", async () => {
@@ -90,15 +96,20 @@ describe("StartAction", () => {
   });
 
   test("should fail when waiting for simulator initialization times out", async () => {
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({ initialized: false, errorCode: "TIMEOUT" });
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
+      initialized: false,
+      errorCode: "TIMEOUT",
+    });
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("The simulator is taking too long to initialize. Please try again later.");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "The simulator is taking too long to initialize. Please try again later.",
+    );
   });
 
   test("should reset the database if resetDb is true", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetDb: true };
+    const options: StartActionOptions = {...defaultOptions, resetDb: true};
 
     mockSimulatorService.cleanDatabase = vi.fn().mockResolvedValue(undefined);
 
@@ -109,13 +120,13 @@ describe("StartAction", () => {
   });
 
   test("should initialize validators when resetValidators is true", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetValidators: true };
+    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
 
     mockSimulatorService.deleteAllValidators = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.createRandomValidators = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.getAiProvidersOptions = vi.fn().mockReturnValue(["Provider1", "Provider2"]);
 
-    vi.mocked(inquirer.prompt).mockResolvedValue({ selectedLlmProviders: ["Provider1"] });
+    vi.mocked(inquirer.prompt).mockResolvedValue({selectedLlmProviders: ["Provider1"]});
 
     await startAction.execute(options);
 
@@ -125,13 +136,18 @@ describe("StartAction", () => {
   });
 
   test("should fail when initializing validators fails", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetValidators: true };
+    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
 
-    mockSimulatorService.deleteAllValidators = vi.fn().mockRejectedValue(new Error("Failed to delete validators"));
+    mockSimulatorService.deleteAllValidators = vi
+      .fn()
+      .mockRejectedValue(new Error("Failed to delete validators"));
 
     await startAction.execute(options);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the validators", expect.any(Error));
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Unable to initialize the validators",
+      expect.any(Error),
+    );
   });
 
   test("should open frontend when not in headless mode", async () => {
@@ -165,7 +181,9 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("The simulator is taking too long to initialize. Please try again later.");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "The simulator is taking too long to initialize. Please try again later.",
+    );
   });
 
   test("should log error message if simulator fails to initialize with ERROR code", async () => {
@@ -177,7 +195,10 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the GenLayer simulator.", "Initialization failed");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Unable to initialize the GenLayer simulator.",
+      "Initialization failed",
+    );
   });
 
   test("catches and logs error if waitForSimulatorToBeReady throws an exception", async () => {
@@ -186,14 +207,17 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error waiting for the simulator to be ready", errorMsg);
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error waiting for the simulator to be ready",
+      errorMsg,
+    );
   });
 
   test("should not append frontend URL when in headless mode", async () => {
-    await startAction.execute({ ...defaultOptions, headless: true });
+    await startAction.execute({...defaultOptions, headless: true});
 
     expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "GenLayer simulator initialized successfully! "
+      "GenLayer simulator initialized successfully! ",
     );
   });
 

package/tests/actions/write.test.ts

@@ -0,0 +1,102 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {WriteAction} from "../../src/commands/contracts/write";
+
+vi.mock("genlayer-js");
+
+describe("WriteAction", () => {
+  let writeAction: WriteAction;
+  const mockClient = {
+    writeContract: vi.fn(),
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    writeAction = new WriteAction();
+    vi.spyOn(writeAction as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+
+    vi.spyOn(writeAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(writeAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("calls writeContract successfully", async () => {
+    const options = {args: [42, "Update"]};
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await writeAction.write({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      ...options,
+    });
+
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42, "Update"],
+      value: 0n,
+    });
+    expect(writeAction["log"]).toHaveBeenCalledWith("Write Transaction Hash:", mockHash);
+    expect(writeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Write operation successfully executed",
+      mockReceipt,
+    );
+  });
+
+  test("handles writeContract errors", async () => {
+    vi.mocked(mockClient.writeContract).mockRejectedValue(new Error("Mocked write error"));
+
+    await writeAction.write({contractAddress: "0xMockedContract", method: "updateData", args: [1]});
+
+    expect(writeAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error during write operation",
+      expect.any(Error),
+    );
+  });
+
+  test("uses custom RPC URL for write operations", async () => {
+    const options = {args: [42, "Update"], rpc: "https://custom-rpc-url.com"};
+    const mockHash = "0xMockedTransactionHash";
+    const mockReceipt = {status: "success"};
+
+    vi.mocked(mockClient.writeContract).mockResolvedValue(mockHash);
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await writeAction.write({
+      contractAddress: "0xMockedContract",
+      method: "updateData",
+      ...options,
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.writeContract).toHaveBeenCalledWith({
+      address: "0xMockedContract",
+      functionName: "updateData",
+      args: [42, "Update"],
+      value: 0n,
+    });
+    expect(writeAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Write operation successfully executed",
+      mockReceipt,
+    );
+  });
+});

package/tests/commands/network.test.ts

@@ -0,0 +1,60 @@
+import {Command} from "commander";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeNetworkCommands} from "../../src/commands/network";
+import {NetworkActions} from "../../src/commands/network/setNetwork";
+
+vi.mock("../../src/commands/network/setNetwork");
+
+describe("network commands", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeNetworkCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("NetworkActions.setNetwork is called with the correct network name", async () => {
+    program.parse(["node", "test", "network", "localnet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("localnet");
+  });
+
+  test("NetworkActions.setNetwork is called with testnet-asimov", async () => {
+    program.parse(["node", "test", "network", "testnet-asimov"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("testnet-asimov");
+  });
+
+  test("NetworkActions.setNetwork is called with studionet", async () => {
+    program.parse(["node", "test", "network", "studionet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("studionet");
+  });
+
+  test("NetworkActions.setNetwork is called without a network name", async () => {
+    program.parse(["node", "test", "network"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith(undefined);
+  });
+
+  test("NetworkActions is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "network", "localnet"]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+  });
+
+  test("NetworkActions.setNetwork is called without throwing errors for valid network", async () => {
+    program.parse(["node", "test", "network", "localnet"]);
+    vi.mocked(NetworkActions.prototype.setNetwork).mockResolvedValue();
+    expect(() => program.parse(["node", "test", "network", "localnet"])).not.toThrow();
+  });
+
+  test("NetworkActions.setNetwork is called with empty string", async () => {
+    program.parse(["node", "test", "network", ""]);
+    expect(NetworkActions).toHaveBeenCalledTimes(1);
+    expect(NetworkActions.prototype.setNetwork).toHaveBeenCalledWith("");
+  });
+});

package/tests/commands/write.test.ts

@@ -0,0 +1,76 @@
+import {Command} from "commander";
+import {WriteAction} from "../../src/commands/contracts/write";
+import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
+import {initializeContractsCommands} from "../../src/commands/contracts";
+
+vi.mock("../../src/commands/contracts/write");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
+
+describe("write command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeContractsCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("WriteAction.write is called with default options", async () => {
+    program.parse(["node", "test", "write", "0xMockedContract", "setData"]);
+    expect(WriteAction).toHaveBeenCalledTimes(1);
+    expect(WriteAction.prototype.write).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "setData",
+      args: [],
+    });
+  });
+
+  test("WriteAction.write is called with positional arguments and options", async () => {
+    program.parse([
+      "node",
+      "test",
+      "write",
+      "0xMockedContract",
+      "updateCounter",
+      "--args",
+      "100",
+      "someString",
+      "true",
+      "--rpc",
+      "https://custom-rpc-url-for-write.com",
+    ]);
+    expect(WriteAction).toHaveBeenCalledTimes(1);
+    expect(WriteAction.prototype.write).toHaveBeenCalledWith({
+      contractAddress: "0xMockedContract",
+      method: "updateCounter",
+      args: [100, "someString", true],
+      rpc: "https://custom-rpc-url-for-write.com",
+    });
+  });
+
+  test("WriteAction is instantiated when the write command is executed", async () => {
+    program.parse(["node", "test", "write", "0xMockedContract", "anotherMethod"]);
+    expect(WriteAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const writeCommand = program.commands.find(cmd => cmd.name() === "write");
+    writeCommand?.exitOverride();
+    expect(() =>
+      program.parse(["node", "test", "write", "0xMockedContract", "someMethod", "--invalid-option"]),
+    ).toThrowError("error: unknown option '--invalid-option'");
+  });
+
+  test("WriteAction.write is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "write", "0xMockedContract", "validMethod"]);
+    vi.mocked(WriteAction.prototype.write).mockResolvedValueOnce(undefined);
+    // Need to parse again inside expect to ensure the mockResolvedValueOnce is used for the assertion context
+    expect(() => program.parse(["node", "test", "write", "0xMockedContract", "validMethod"])).not.toThrow();
+  });
+});

package/tests/index.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, vi, expect } from "vitest";
-import { initializeCLI } from "../src/index";
+import {describe, it, vi, expect} from "vitest";
+import {initializeCLI} from "../src/index";
 
 vi.mock("commander", () => ({
   program: {
@@ -37,6 +37,9 @@ vi.mock("../src/commands/scaffold", () => ({
   initializeScaffoldCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/network", () => ({
+  initializeNetworkCommands: vi.fn(),
+}));
 
 describe("CLI", () => {
   it("should initialize CLI", () => {

package/tests/libs/baseAction.test.ts

@@ -1,7 +1,7 @@
 import {describe, test, vi, beforeEach, afterEach, expect, Mock} from "vitest";
-import { BaseAction } from "../../src/lib/actions/BaseAction";
+import {BaseAction} from "../../src/lib/actions/BaseAction";
 import inquirer from "inquirer";
-import ora, { Ora } from "ora";
+import ora, {Ora} from "ora";
 import chalk from "chalk";
 
 vi.mock("inquirer");
@@ -61,14 +61,14 @@ describe("BaseAction", () => {
   });
 
   test("should confirm prompt and proceed when confirmed", async () => {
-    vi.mocked(inquirer.prompt).mockResolvedValue({ confirmAction: true });
+    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 });
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
     const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
       throw new Error("process exited");
     });
@@ -103,7 +103,7 @@ describe("BaseAction", () => {
   });
 
   test("should log a success message with data", () => {
-    const data = { key: "value" };
+    const data = {key: "value"};
 
     baseAction["logSuccess"]("Success message", data);
 
@@ -117,14 +117,22 @@ describe("BaseAction", () => {
     baseAction["logError"]("Error message", error);
 
     expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
-    expect(consoleErrorSpy).toHaveBeenCalledWith(chalk.red(JSON.stringify({
-      name: error.name,
-      message: error.message,
-    }, null, 2)));
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      chalk.red(
+        JSON.stringify(
+          {
+            name: error.name,
+            message: error.message,
+          },
+          null,
+          2,
+        ),
+      ),
+    );
   });
 
   test("should log an info message with data", () => {
-    const data = { info: "This is some info" };
+    const data = {info: "This is some info"};
 
     baseAction["logInfo"]("Info message", data);
 
@@ -133,7 +141,7 @@ describe("BaseAction", () => {
   });
 
   test("should log a warning message with data", () => {
-    const data = { warning: "This is a warning" };
+    const data = {warning: "This is a warning"};
 
     baseAction["logWarning"]("Warning message", data);
 
@@ -142,7 +150,7 @@ describe("BaseAction", () => {
   });
 
   test("should succeed the spinner with a message and log result if data is provided", () => {
-    const mockData = { key: "value" };
+    const mockData = {key: "value"};
 
     baseAction["succeedSpinner"]("Success", mockData);
 
@@ -156,11 +164,11 @@ describe("BaseAction", () => {
     (error as any).code = 500;
 
     const result = (baseAction as any).formatOutput(error);
-    expect(result).toBe(JSON.stringify({ name: "Error", message: "Something went wrong", code: 500 }, null, 2));
+    expect(result).toBe(JSON.stringify({name: "Error", message: "Something went wrong", code: 500}, null, 2));
   });
 
   test("should format an object as JSON string", () => {
-    const data = { key: "value", num: 42 };
+    const data = {key: "value", num: 42};
     const result = (baseAction as any).formatOutput(data);
 
     expect(result).toBe(JSON.stringify(data, null, 2));
@@ -176,16 +184,20 @@ describe("BaseAction", () => {
     const testMap = new Map<string, any>([
       ["key1", "value1"],
       ["key2", 42],
-      ["key3", { nested: "object" }]
+      ["key3", {nested: "object"}],
     ]);
-    
+
     const result = (baseAction as any).formatOutput(testMap);
-    const expected = JSON.stringify({
-      key1: "value1",
-      key2: 42,
-      key3: { nested: "object" }
-    }, null, 2);
-    
+    const expected = JSON.stringify(
+      {
+        key1: "value1",
+        key2: 42,
+        key3: {nested: "object"},
+      },
+      null,
+      2,
+    );
+
     expect(result).toBe(expected);
   });
 
@@ -198,7 +210,6 @@ describe("BaseAction", () => {
       getKeypairPath: vi.fn(),
       setKeypairPath: vi.fn(),
     } as any;
-
   });
 
   test("should return private key when it exists", async () => {
@@ -214,15 +225,15 @@ describe("BaseAction", () => {
     vi.mocked(baseAction["keypairManager"].getPrivateKey)
       .mockReturnValueOnce(undefined)
       .mockReturnValueOnce(mockPrivateKey);
-      vi.mocked(inquirer.prompt).mockResolvedValue({ confirmAction: true });
-      await baseAction["getPrivateKey"]();
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: true});
+    await baseAction["getPrivateKey"]();
 
     expect(baseAction["keypairManager"].createKeypair).toHaveBeenCalled();
   });
 
   test("should exit when private key doesn't exist and user declines", async () => {
     vi.mocked(baseAction["keypairManager"].getPrivateKey).mockReturnValueOnce(undefined);
-    vi.mocked(inquirer.prompt).mockResolvedValue({ confirmAction: false });
+    vi.mocked(inquirer.prompt).mockResolvedValue({confirmAction: false});
     vi.spyOn(process, "exit").mockImplementation(() => {
       throw new Error("process exited");
     });