genlayer 0.18.1 → 0.18.2-beta.0

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/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/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");
     });