genlayer 0.33.1 → 0.34.1

package/tests/actions/ollama.test.ts

@@ -1,193 +0,0 @@
-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

@@ -1,261 +0,0 @@
-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

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