genlayer 0.38.8 → 0.38.10

package/tests/actions/new.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import fs from "fs-extra";
+import path from "path";
+import { NewAction } from "../../src/commands/scaffold/new";
+
+vi.mock("fs-extra");
+
+describe("NewAction", () => {
+  let newAction: NewAction;
+  let mockExistsSync: any;
+  let mockCopySync: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    newAction = new NewAction();
+
+    mockExistsSync = vi.mocked(fs.existsSync);
+    mockCopySync = vi.mocked(fs.copySync);
+
+    vi.spyOn(newAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(newAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(newAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("should successfully create a new project", async () => {
+    mockExistsSync.mockReturnValue(false);
+    mockCopySync.mockImplementation(() => {});
+
+    await newAction.createProject("myProject", { path: ".", overwrite: false });
+
+    expect(newAction["startSpinner"]).toHaveBeenCalledWith("Creating new GenLayer project: myProject");
+    expect(mockCopySync).toHaveBeenCalledWith(expect.any(String), path.resolve(".", "myProject"));
+    expect(newAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Project "myProject" created successfully at ${path.resolve(".", "myProject")}`
+    );
+  });
+
+  test("should fail if project directory exists and overwrite is not set", async () => {
+    mockExistsSync.mockReturnValue(true);
+
+    await newAction.createProject("existingProject", { path: ".", overwrite: false });
+
+    expect(newAction["failSpinner"]).toHaveBeenCalledWith(
+      `Project directory "${path.resolve(".", "existingProject")}" already exists. Use --overwrite to replace it.`
+    );
+    expect(mockCopySync).not.toHaveBeenCalled();
+  });
+
+  test("should overwrite existing project if overwrite is set", async () => {
+    mockExistsSync.mockReturnValue(true);
+    mockCopySync.mockImplementation(() => {});
+
+    await newAction.createProject("overwriteProject", { path: ".", overwrite: true });
+
+    expect(newAction["startSpinner"]).toHaveBeenCalledWith("Creating new GenLayer project: overwriteProject");
+    expect(mockCopySync).toHaveBeenCalledWith(expect.any(String), path.resolve(".", "overwriteProject"));
+    expect(newAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Project "overwriteProject" created successfully at ${path.resolve(".", "overwriteProject")}`
+    );
+  });
+
+  test("should fail if an error occurs while copying files", async () => {
+    mockExistsSync.mockReturnValue(false);
+    const error = new Error("Mocked file system error");
+    mockCopySync.mockImplementation(() => {
+      throw error;
+    });
+
+    await newAction.createProject("errorProject", { path: ".", overwrite: false });
+
+    expect(newAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error creating project \"errorProject\"",
+      error
+    );
+  });
+});

package/tests/actions/ollama.test.ts

@@ -0,0 +1,193 @@
+import { describe, test, vi, beforeEach, afterEach, expect, Mock } from "vitest";
+import { OllamaAction } from "../../src/commands/update/ollama";
+import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
+import Docker from "dockerode";
+
+vi.mock("dockerode");
+vi.mock("../../src/lib/clients/jsonRpcClient");
+
+describe("OllamaAction", () => {
+  let ollamaAction: OllamaAction;
+  let mockGetContainer: Mock;
+  let mockExec: Mock;
+  let mockStart: Mock;
+  let mockStream: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ollamaAction = new OllamaAction();
+
+    mockGetContainer = vi.mocked(Docker.prototype.getContainer);
+    mockExec = vi.fn();
+    mockStart = vi.fn();
+
+    mockStream = {
+      on: vi.fn(),
+    };
+
+    mockExec.mockResolvedValue({
+      start: mockStart,
+    });
+
+    mockStart.mockResolvedValue(mockStream);
+
+    mockGetContainer.mockReturnValue({
+      exec: mockExec,
+    } as unknown as Docker.Container);
+
+    Docker.prototype.getContainer = mockGetContainer;
+
+    vi.spyOn(ollamaAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("should update the model using 'pull'", async () => {
+    const mockProvider = {
+      plugin: "ollama",
+      config: { key: "value" },
+      plugin_config: { pluginKey: "pluginValue" },
+    };
+
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({
+      result: [mockProvider],
+    });
+
+    mockStream.on.mockImplementation((event: any, callback: any) => {
+      if (event === "data") {
+        callback(Buffer.from("Mocked output success"));
+      }
+      if (event === "end") {
+        callback();
+      }
+    });
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["startSpinner"]).toHaveBeenCalledWith(`Updating model "mocked_model"...`);
+    expect(mockGetContainer).toHaveBeenCalledWith("genlayer-ollama");
+    expect(mockExec).toHaveBeenCalledWith({
+      Cmd: ["ollama", "pull", "mocked_model"],
+      AttachStdout: true,
+      AttachStderr: true,
+    });
+    expect(mockStart).toHaveBeenCalledWith({ Detach: false, Tty: false });
+    expect(ollamaAction["setSpinnerText"]).toHaveBeenCalledWith("Mocked output success");
+    expect(ollamaAction["succeedSpinner"]).toHaveBeenCalledWith(`Model "mocked_model" updated successfully`);
+  });
+
+  test("should remove the model using 'rm'", async () => {
+    mockStream.on.mockImplementation((event: any, callback: any) => {
+      if (event === "data") {
+        callback(Buffer.from("Mocked output success"));
+      }
+      if (event === "end") {
+        callback();
+      }
+    });
+
+    await ollamaAction.removeModel("mocked_model");
+
+    expect(ollamaAction["startSpinner"]).toHaveBeenCalledWith(`Executing 'rm' command on model "mocked_model"...`);
+    expect(mockGetContainer).toHaveBeenCalledWith("genlayer-ollama");
+    expect(mockExec).toHaveBeenCalledWith({
+      Cmd: ["ollama", "rm", "mocked_model"],
+      AttachStdout: true,
+      AttachStderr: true,
+    });
+    expect(mockStart).toHaveBeenCalledWith({ Detach: false, Tty: false });
+    expect(ollamaAction["setSpinnerText"]).toHaveBeenCalledWith("Mocked output success");
+    expect(ollamaAction["succeedSpinner"]).toHaveBeenCalledWith(`Model "mocked_model" removed successfully`);
+  });
+
+  test("should log an error if an exception occurs during 'pull'", async () => {
+    const mockProvider = {
+      plugin: "ollama",
+      config: { key: "value" },
+      plugin_config: { pluginKey: "pluginValue" },
+    };
+
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({
+      result: [mockProvider],
+    });
+
+    const error = new Error("Mocked error");
+    mockExec.mockRejectedValue(error);
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error executing command "pull" on model "mocked_model"`, error);
+  });
+
+  test("should log an error if an exception occurs during 'rm'", async () => {
+    const error = new Error("Mocked error");
+    mockExec.mockRejectedValue(error);
+
+    await ollamaAction.removeModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error executing command "rm" on model "mocked_model"`, error);
+  });
+
+  test("should throw an error if no 'ollama' provider exists during updateModel", async () => {
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({
+      result: [],
+    });
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(
+      "No existing 'ollama' provider found. Unable to add/update a model."
+    );
+  });
+
+  test("should reject with an error if success is not set to true", async () => {
+    const mockProvider = {
+      plugin: "ollama",
+      config: { key: "value" },
+      plugin_config: { pluginKey: "pluginValue" },
+    };
+
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({
+      result: [mockProvider],
+    });
+
+    mockStream.on.mockImplementation((event: any, callback: any) => {
+      if (event === "data") {
+        callback(Buffer.from("Mocked output failure"));
+      }
+      if (event === "end") {
+        callback();
+      }
+    });
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(
+      `Failed to execute 'pull' on model "mocked_model".`
+    );
+  });
+
+  test("should log an error if an exception occurs inside updateModel", async () => {
+    const mockError = new Error("Mocked error");
+
+    vi.mocked(rpcClient.request).mockRejectedValue(mockError);
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error updating model "mocked_model"`, mockError);
+  });
+
+  test("should call get config if modelName is empty", async () => {
+    const defaultModel = "default_model";
+    vi.spyOn(ollamaAction as any, "getConfig").mockReturnValue({ defaultOllamaModel: defaultModel });
+
+    await ollamaAction.updateModel("");
+    expect(ollamaAction.getConfig).toHaveBeenCalledTimes(1);
+  });
+
+});

package/tests/actions/receipt.test.ts

@@ -0,0 +1,261 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import type {TransactionHash} from "genlayer-js/types";
+import {TransactionStatus} from "genlayer-js/types";
+import {ReceiptAction, type ReceiptParams} from "../../src/commands/transactions/receipt";
+
+vi.mock("genlayer-js");
+
+describe("ReceiptAction", () => {
+  let receiptAction: ReceiptAction;
+  const mockClient = {
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
+  };
+
+  const mockPrivateKey = "mocked_private_key";
+  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234" as TransactionHash;
+  const defaultRetries = 100;
+  const defaultInterval = 5000;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(createClient).mockReturnValue(mockClient as any);
+    vi.mocked(createAccount).mockReturnValue({privateKey: mockPrivateKey} as any);
+    receiptAction = new ReceiptAction();
+    vi.spyOn(receiptAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(receiptAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(receiptAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(receiptAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("retrieves transaction receipt successfully with default options", async () => {
+    const mockReceipt = {status: "FINALIZED", data: {hash: mockTxId}};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+    });
+
+    expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+      hash: mockTxId,
+      status: TransactionStatus.FINALIZED,
+      retries: defaultRetries,
+      interval: defaultInterval,
+    });
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction receipt retrieved successfully",
+      mockReceipt,
+    );
+  });
+
+  test("retrieves transaction receipt with custom options", async () => {
+    const mockReceipt = {status: "ACCEPTED", data: {hash: mockTxId}};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      status: "ACCEPTED",
+      retries: 50,
+      interval: 3000,
+    });
+
+    expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+      hash: mockTxId,
+      status: TransactionStatus.ACCEPTED,
+      retries: 50,
+      interval: 3000,
+    });
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction receipt retrieved successfully",
+      mockReceipt,
+    );
+  });
+
+  test("handles waitForTransactionReceipt errors", async () => {
+    vi.mocked(mockClient.waitForTransactionReceipt).mockRejectedValue(new Error("Mocked receipt error"));
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+    });
+
+    expect(receiptAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error retrieving transaction receipt",
+      expect.any(Error),
+    );
+  });
+
+  test("uses custom RPC URL for receipt operations", async () => {
+    const rpcUrl = "https://custom-rpc-url.com";
+    const mockReceipt = {status: "FINALIZED", data: {hash: mockTxId}};
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+      rpc: rpcUrl,
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: rpcUrl,
+      }),
+    );
+    expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+      hash: mockTxId,
+      status: TransactionStatus.FINALIZED,
+      retries: defaultRetries,
+      interval: defaultInterval,
+    });
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction receipt retrieved successfully",
+      mockReceipt,
+    );
+  });
+
+  test("validates transaction status and shows error for invalid status", async () => {
+    await receiptAction.receipt({
+      txId: mockTxId,
+      status: "INVALID_STATUS",
+      retries: defaultRetries,
+      interval: defaultInterval,
+    });
+
+    expect(receiptAction["failSpinner"]).toHaveBeenCalledWith(
+      "Invalid transaction status",
+      expect.stringContaining("Invalid status: INVALID_STATUS")
+    );
+    
+    expect(mockClient.waitForTransactionReceipt).not.toHaveBeenCalled();
+  });
+
+  test("accepts valid transaction statuses", async () => {
+    const mockReceipt = {status: "PENDING", data: {hash: mockTxId}};
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt);
+
+    const testStatuses = [
+      {input: "accepted", expected: TransactionStatus.ACCEPTED},
+      {input: "FINALIZED", expected: TransactionStatus.FINALIZED},
+      {input: "pending", expected: TransactionStatus.PENDING},
+      {input: "COMMITTING", expected: TransactionStatus.COMMITTING},
+    ];
+
+    for (const {input, expected} of testStatuses) {
+      await receiptAction.receipt({
+        txId: mockTxId,
+        status: input,
+        retries: defaultRetries,
+        interval: defaultInterval,
+      });
+
+      expect(mockClient.waitForTransactionReceipt).toHaveBeenCalledWith({
+        hash: mockTxId,
+        status: expected,
+        retries: defaultRetries,
+        interval: defaultInterval,
+      });
+    }
+  });
+
+  test("prints only stdout when --stdout is provided", async () => {
+    const mockReceipt = {
+      consensus_data: {
+        leader_receipt: [
+          {
+            genvm_result: {
+              stdout: "program stdout",
+              stderr: "program stderr",
+            },
+          },
+        ],
+      },
+    };
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt as any);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+      stdout: true,
+    } as ReceiptParams);
+
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction stdout retrieved successfully",
+      "program stdout",
+    );
+  });
+
+  test("prints only stderr when --stderr is provided", async () => {
+    const mockReceipt = {
+      consensus_data: {
+        leader_receipt: [
+          {
+            genvm_result: {
+              stdout: "program stdout",
+              stderr: "program stderr",
+            },
+          },
+        ],
+      },
+    };
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt as any);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+      stderr: true,
+    } as ReceiptParams);
+
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction stderr retrieved successfully",
+      "program stderr",
+    );
+  });
+
+  test("prints both stdout and stderr when both flags are provided", async () => {
+    const mockReceipt = {
+      consensus_data: {
+        leader_receipt: [
+          {
+            genvm_result: {
+              stdout: "program stdout",
+              stderr: "program stderr",
+            },
+          },
+        ],
+      },
+    };
+
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue(mockReceipt as any);
+
+    await receiptAction.receipt({
+      txId: mockTxId,
+      retries: defaultRetries,
+      interval: defaultInterval,
+      stdout: true,
+      stderr: true,
+    } as ReceiptParams);
+
+    expect(receiptAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Transaction stdout and stderr",
+      { stdout: "program stdout", stderr: "program stderr" },
+    );
+  });
+
+}); 

package/tests/actions/schema.test.ts

@@ -0,0 +1,94 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {createClient, createAccount} from "genlayer-js";
+import {SchemaAction} from "../../src/commands/contracts/schema";
+
+vi.mock("genlayer-js");
+
+describe("SchemaAction", () => {
+  let schemaAction: SchemaAction;
+  const mockClient = {
+    getContractSchema: 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);
+    schemaAction = new SchemaAction();
+    vi.spyOn(schemaAction as any, "getAccount").mockResolvedValue({privateKey: mockPrivateKey});
+
+    vi.spyOn(schemaAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(schemaAction as any, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("gets contract schema successfully", async () => {
+    const mockResult = {
+      methods: {
+        getData: {
+          params: [["value", "int"]],
+          ret: "int",
+          readonly: true,
+        },
+      },
+    };
+
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({
+      contractAddress: "0xMockedContract",
+    });
+
+    expect(mockClient.getContractSchema).toHaveBeenCalledWith("0xMockedContract");
+    expect(schemaAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract schema retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("handles getContractSchema errors", async () => {
+    vi.mocked(mockClient.getContractSchema).mockRejectedValue(new Error("Mocked schema error"));
+
+    await schemaAction.schema({contractAddress: "0xMockedContract"});
+
+    expect(schemaAction["failSpinner"]).toHaveBeenCalledWith("Error retrieving contract schema", expect.any(Error));
+  });
+
+  test("uses custom RPC URL when provided", async () => {
+    const mockResult = {methods: {}};
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({
+      contractAddress: "0xMockedContract",
+      rpc: "https://custom-rpc-url.com",
+    });
+
+    expect(createClient).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: "https://custom-rpc-url.com",
+      }),
+    );
+    expect(mockClient.getContractSchema).toHaveBeenCalledWith("0xMockedContract");
+    expect(schemaAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "Contract schema retrieved successfully",
+      mockResult,
+    );
+  });
+
+  test("initializes consensus smart contract", async () => {
+    const mockResult = {methods: {}};
+    vi.mocked(mockClient.getContractSchema).mockResolvedValue(mockResult);
+
+    await schemaAction.schema({contractAddress: "0xMockedContract"});
+
+    expect(mockClient.initializeConsensusSmartContract).toHaveBeenCalled();
+  });
+});