genlayer 0.33.1 → 0.34.1

package/tests/commands/init.test.ts

@@ -1,101 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeGeneralCommands } from "../../src/commands/general";
-import { getCommand, getCommandOption } from "../utils";
-import simulatorService from  '../../src/lib/services/simulator'
-import {localnetCompatibleVersion} from "../../src/lib/config/simulator";
-import { InitAction } from "../../src/commands/general/init";
-
-
-vi.mock("../../src/commands/general/init");
-
-
-const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
-const defaultOptions = {
-  numValidators: "5",
-  headless: false,
-  resetDb: false,
-  localnetVersion: localnetCompatibleVersion,
-  ollama: false,
-}
-
-vi.mock("inquirer", () => ({
-  prompt: vi.fn(() => {}),
-}));
-
-describe("init command", () => {
-  let initCommand: Command;
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeGeneralCommands(program);
-
-    initCommand = getCommand(program, "init");
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("doesn't have required arguments nor options", async () => {
-    expect(() => program.parse(["node", "test", "init"])).not.toThrow();
-  });
-
-  test("option --numValidators is accepted", async () => {
-    expect(() => program.parse(["node", "test", "init", "--numValidators", "10"])).not.toThrow();
-  });
-
-  test("option --numValidators default value is 5", async () => {
-    const numValidatorsOption = getCommandOption(initCommand, "--numValidators");
-    expect(numValidatorsOption?.defaultValue).toBe("5");
-  });
-
-
-  test("random option is not accepted", async () => {
-    initCommand?.exitOverride();
-    expect(() => program.parse(["node", "test", "init", "-random"])).toThrowError(
-      "error: unknown option '-random'"
-    );
-    expect(() => program.parse(["node", "test", "init", "--randomOption"])).toThrowError(
-      "error: unknown option '--randomOption'"
-    );
-  });
-
-  test("action is called", async () => {
-    program.parse(["node", "test", "init"]);
-    expect(InitAction).toHaveBeenCalledTimes(1);
-    expect(InitAction.prototype.execute).toHaveBeenCalledWith(defaultOptions);
-  });
-
-  test("option --headless is accepted", async () => {
-    program.parse(["node", "test", "init", "--headless"]);
-    expect(InitAction).toHaveBeenCalledTimes(1);
-    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, headless: true});
-    expect(openFrontendSpy).not.toHaveBeenCalled();
-  });
-
-  test("option --localnet-version is accepted", async () => {
-    program.parse(["node", "test", "init", "--localnet-version", "v1.0.0"]);
-    expect(InitAction).toHaveBeenCalledTimes(1);
-    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
-    expect(openFrontendSpy).not.toHaveBeenCalled();
-  });
-
-  test("option --localnet-version description includes minimum version", async () => {
-    const localnetVersionOption = getCommandOption(initCommand, "--localnet-version");
-    expect(localnetVersionOption?.description).toBe(`Select a specific localnet version (minimum: ${localnetCompatibleVersion})`);
-  });
-
-  test("option --localnet-version default value is compatible version", async () => {
-    const localnetVersionOption = getCommandOption(initCommand, "--localnet-version");
-    expect(localnetVersionOption?.defaultValue).toBe(localnetCompatibleVersion);
-  });
-
-  test("option --ollama is accepted", async () => {
-    program.parse(["node", "test", "init", "--ollama"]);
-    expect(InitAction).toHaveBeenCalledTimes(1);
-    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, ollama: true});
-  });
-});

package/tests/commands/localnet.test.ts

@@ -1,131 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeValidatorCommands } from "../../src/commands/localnet";
-import { ValidatorsAction } from "../../src/commands/localnet/validators";
-
-vi.mock("../../src/commands/localnet/validators");
-
-describe("localnet validator command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeValidatorCommands(program);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("ValidatorsAction.getValidator is called with address option", async () => {
-    program.parse(["node", "test", "localnet", "validators", "get", "--address", "mocked_address"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.getValidator).toHaveBeenCalledWith({
-      address: "mocked_address",
-    });
-  });
-
-  test("ValidatorsAction.getValidator is called without address option", async () => {
-    program.parse(["node", "test", "localnet", "validators", "get"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.getValidator).toHaveBeenCalledWith({});
-  });
-
-  test("ValidatorsAction.deleteValidator is called with address option", async () => {
-    program.parse(["node", "test", "localnet", "validators", "delete", "--address", "mocked_address"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.deleteValidator).toHaveBeenCalledWith({
-      address: "mocked_address",
-    });
-  });
-
-  test("ValidatorsAction.deleteValidator is called without address option", async () => {
-    program.parse(["node", "test", "localnet", "validators", "delete"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.deleteValidator).toHaveBeenCalledWith({});
-  });
-
-  test("ValidatorsAction.countValidators is called", async () => {
-    program.parse(["node", "test", "localnet", "validators", "count"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.countValidators).toHaveBeenCalled();
-  });
-
-  test("ValidatorsAction.updateValidator is called with all options", async () => {
-    program.parse([
-      "node",
-      "test",
-      "localnet",
-      "validators",
-      "update",
-      "mocked_address",
-      "--stake",
-      "10",
-      "--provider",
-      "mocked_provider",
-      "--model",
-      "mocked_model",
-      '--config',
-      '{"max_tokens":500}',
-    ]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.updateValidator).toHaveBeenCalledWith({
-      address: "mocked_address",
-      stake: "10",
-      provider: "mocked_provider",
-      model: "mocked_model",
-      config: '{"max_tokens":500}',
-    });
-  });
-
-  test("ValidatorsAction.createRandomValidators is called with count and providers", async () => {
-    program.parse([
-      "node",
-      "test",
-      "localnet",
-      "validators",
-      "create-random",
-      "--count",
-      "3",
-      "--providers",
-      "provider1",
-      "provider2",
-    ]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.createRandomValidators).toHaveBeenCalledWith({
-      count: "3",
-      providers: ["provider1", "provider2"],
-      models: []
-    });
-  });
-
-  test("ValidatorsAction.createValidator is called with default stake", async () => {
-    program.parse(["node", "test", "localnet", "validators", "create"]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.createValidator).toHaveBeenCalledWith({
-      stake: "1",
-      config: undefined,
-    });
-  });
-
-  test("ValidatorsAction.createValidator is called with stake and config", async () => {
-    program.parse([
-      "node",
-      "test",
-      "localnet",
-      "validators",
-      "create",
-      "--stake",
-      "5",
-      '--config',
-      '{"temperature":0.8}',
-    ]);
-    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
-    expect(ValidatorsAction.prototype.createValidator).toHaveBeenCalledWith({
-      stake: "5",
-      config: '{"temperature":0.8}',
-    });
-  });
-});
-
-

package/tests/commands/network.test.ts

@@ -1,60 +0,0 @@
-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", "set", "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", "set", "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", "set", "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", "set"]);
-    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", "set", "localnet"]);
-    expect(NetworkActions).toHaveBeenCalledTimes(1);
-  });
-
-  test("NetworkActions.setNetwork is called without throwing errors for valid network", async () => {
-    program.parse(["node", "test", "network", "set", "localnet"]);
-    vi.mocked(NetworkActions.prototype.setNetwork).mockResolvedValue();
-    expect(() => program.parse(["node", "test", "network", "set", "localnet"])).not.toThrow();
-  });
-
-  test("NetworkActions.showInfo is called for network info", async () => {
-    program.parse(["node", "test", "network", "info"]);
-    expect(NetworkActions).toHaveBeenCalledTimes(1);
-    expect(NetworkActions.prototype.showInfo).toHaveBeenCalled();
-  });
-});

package/tests/commands/new.test.ts

@@ -1,68 +0,0 @@
-import { Command } from "commander";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeScaffoldCommands } from "../../src/commands/scaffold";
-import { NewAction } from "../../src/commands/scaffold/new";
-
-vi.mock("../../src/commands/scaffold/new");
-
-describe("new command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeScaffoldCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("NewAction.createProject is called with default options", async () => {
-    program.parse(["node", "test", "new", "myProject"]);
-    expect(NewAction).toHaveBeenCalledTimes(1);
-    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
-      path: ".",
-      overwrite: false,
-    });
-  });
-
-  test("NewAction.createProject is called with custom path", async () => {
-    program.parse(["node", "test", "new", "myProject", "--path", "./customDir"]);
-    expect(NewAction).toHaveBeenCalledTimes(1);
-    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
-      path: "./customDir",
-      overwrite: false,
-    });
-  });
-
-  test("NewAction.createProject is called with overwrite flag", async () => {
-    program.parse(["node", "test", "new", "myProject", "--overwrite"]);
-    expect(NewAction).toHaveBeenCalledTimes(1);
-    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
-      path: ".",
-      overwrite: true,
-    });
-  });
-
-  test("NewAction is instantiated when the new command is executed", async () => {
-    program.parse(["node", "test", "new", "myProject"]);
-    expect(NewAction).toHaveBeenCalledTimes(1);
-  });
-
-  test("throws error for unrecognized options", async () => {
-    const newCommand = program.commands.find((cmd) => cmd.name() === "new");
-    newCommand?.exitOverride();
-    expect(() => program.parse(["node", "test", "new", "myProject", "--unknown"])).toThrowError(
-      "error: unknown option '--unknown'"
-    );
-  });
-
-  test("NewAction.createProject is called without throwing errors for valid options", async () => {
-    program.parse(["node", "test", "new", "myProject"]);
-    vi.mocked(NewAction.prototype.createProject).mockResolvedValueOnce(undefined);
-    expect(() =>
-      program.parse(["node", "test", "new", "myProject"])
-    ).not.toThrow();
-  });
-});

package/tests/commands/receipt.test.ts

@@ -1,142 +0,0 @@
-import {Command} from "commander";
-import {ReceiptAction} from "../../src/commands/transactions/receipt";
-import {vi, describe, beforeEach, afterEach, test, expect} from "vitest";
-import {initializeTransactionsCommands} from "../../src/commands/transactions";
-
-vi.mock("../../src/commands/transactions/receipt");
-
-describe("receipt command", () => {
-  let program: Command;
-  const mockTxId = "0x1234567890123456789012345678901234567890123456789012345678901234";
-
-  beforeEach(() => {
-    program = new Command();
-    initializeTransactionsCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("ReceiptAction.receipt is called with default options", async () => {
-    program.parse(["node", "test", "receipt", mockTxId]);
-    expect(ReceiptAction).toHaveBeenCalledTimes(1);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 100,
-      interval: 5000,
-    });
-  });
-
-  test("ReceiptAction.receipt is called with custom options", async () => {
-    program.parse([
-      "node",
-      "test",
-      "receipt",
-      mockTxId,
-      "--status",
-      "ACCEPTED",
-      "--retries",
-      "50",
-      "--interval",
-      "3000",
-      "--rpc",
-      "https://custom-rpc-url-for-receipt.com",
-    ]);
-    expect(ReceiptAction).toHaveBeenCalledTimes(1);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "ACCEPTED",
-      retries: 50,
-      interval: 3000,
-      rpc: "https://custom-rpc-url-for-receipt.com",
-    });
-  });
-
-  test("ReceiptAction is instantiated when the receipt command is executed", async () => {
-    program.parse(["node", "test", "receipt", mockTxId]);
-    expect(ReceiptAction).toHaveBeenCalledTimes(1);
-  });
-
-  test("throws error for unrecognized options", async () => {
-    const receiptCommand = program.commands.find(cmd => cmd.name() === "receipt");
-    receiptCommand?.exitOverride();
-    expect(() =>
-      program.parse(["node", "test", "receipt", mockTxId, "--invalid-option"]),
-    ).toThrowError("error: unknown option '--invalid-option'");
-  });
-
-  test("parses numeric options correctly", async () => {
-    program.parse([
-      "node",
-      "test",
-      "receipt",
-      mockTxId,
-      "--retries",
-      "25",
-      "--interval",
-      "1000",
-    ]);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 25,
-      interval: 1000,
-    });
-  });
-
-  test("uses fallback value for invalid numeric options", async () => {
-    program.parse([
-      "node",
-      "test",
-      "receipt", 
-      mockTxId,
-      "--retries",
-      "invalid",
-      "--interval", 
-      "notanumber",
-    ]);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 100,
-      interval: 5000,
-    });
-  });
-
-  test("parses --stdout flag", async () => {
-    program.parse(["node", "test", "receipt", mockTxId, "--stdout"]);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 100,
-      interval: 5000,
-      stdout: true,
-    });
-  });
-
-  test("parses --stderr flag", async () => {
-    program.parse(["node", "test", "receipt", mockTxId, "--stderr"]);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 100,
-      interval: 5000,
-      stderr: true,
-    });
-  });
-
-  test("parses both --stdout and --stderr flags", async () => {
-    program.parse(["node", "test", "receipt", mockTxId, "--stdout", "--stderr"]);
-    expect(ReceiptAction.prototype.receipt).toHaveBeenCalledWith({
-      txId: mockTxId,
-      status: "FINALIZED",
-      retries: 100,
-      interval: 5000,
-      stdout: true,
-      stderr: true,
-    });
-  });
-}); 

package/tests/commands/schema.test.ts

@@ -1,67 +0,0 @@
-import { Command } from "commander";
-import { SchemaAction } from "../../src/commands/contracts/schema";
-import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
-import { initializeContractsCommands } from "../../src/commands/contracts";
-
-vi.mock("../../src/commands/contracts/schema");
-vi.mock("esbuild", () => ({
-  buildSync: vi.fn(),
-}));
-
-describe("schema command", () => {
-  let program: Command;
-
-  beforeEach(() => {
-    program = new Command();
-    initializeContractsCommands(program);
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  test("SchemaAction.schema is called with default options", async () => {
-    program.parse(["node", "test", "schema", "0xMockedContract"]);
-    expect(SchemaAction).toHaveBeenCalledTimes(1);
-    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-    });
-  });
-
-  test("SchemaAction.schema is called with custom RPC URL", async () => {
-    program.parse([
-      "node",
-      "test",
-      "schema",
-      "0xMockedContract",
-      "--rpc",
-      "https://custom-rpc-url.com"
-    ]);
-    expect(SchemaAction).toHaveBeenCalledTimes(1);
-    expect(SchemaAction.prototype.schema).toHaveBeenCalledWith({
-      contractAddress: "0xMockedContract",
-      rpc: "https://custom-rpc-url.com"
-    });
-  });
-
-  test("SchemaAction is instantiated when the schema command is executed", async () => {
-    program.parse(["node", "test", "schema", "0xMockedContract"]);
-    expect(SchemaAction).toHaveBeenCalledTimes(1);
-  });
-
-  test("throws error for unrecognized options", async () => {
-    const schemaCommand = program.commands.find((cmd) => cmd.name() === "schema");
-    schemaCommand?.exitOverride();
-    expect(() => program.parse(["node", "test", "schema", "0xMockedContract", "--unknown"]))
-      .toThrowError("error: unknown option '--unknown'");
-  });
-
-  test("SchemaAction.schema is called without throwing errors for valid options", async () => {
-    program.parse(["node", "test", "schema", "0xMockedContract"]);
-    vi.mocked(SchemaAction.prototype.schema).mockResolvedValueOnce(undefined);
-    expect(() =>
-      program.parse(["node", "test", "schema", "0xMockedContract"])
-    ).not.toThrow();
-  });
-});