genlayer 0.12.1 → 0.12.2-beta.0

package/tests/commands/call.test.ts

@@ -1,9 +1,12 @@
 import { Command } from "commander";
+import { CallAction } from "../../src/commands/contracts/call";
 import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeContractsCommands } from "../../src/commands/contracts";
-import { CallAction } from "../../src/commands/contracts/call";
 
 vi.mock("../../src/commands/contracts/call");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 
 describe("call command", () => {
   let program: Command;

package/tests/commands/deploy.test.ts

@@ -4,6 +4,9 @@ import { initializeContractsCommands } from "../../src/commands/contracts";
 import { DeployAction } from "../../src/commands/contracts/deploy";
 
 vi.mock("../../src/commands/contracts/deploy");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 
 describe("deploy command", () => {
   let program: Command;
@@ -66,4 +69,12 @@ describe("deploy command", () => {
       program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"])
     ).not.toThrow();
   });
+
+  test("DeployAction.deployScripts is called without throwing errors", async () => {
+    program.parse(["node", "test", "deploy"]);
+    vi.mocked(DeployAction.prototype.deployScripts).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "deploy"])
+    ).not.toThrow();
+  });
 });

package/tests/commands/init.test.ts

@@ -4,6 +4,11 @@ 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 = {
@@ -17,8 +22,6 @@ vi.mock("inquirer", () => ({
   prompt: vi.fn(() => {}),
 }));
 
-const action = vi.fn();
-
 describe("init command", () => {
   let initCommand: Command;
   let program: Command;
@@ -28,10 +31,6 @@ describe("init command", () => {
     initializeGeneralCommands(program);
 
     initCommand = getCommand(program, "init");
-    initCommand?.action(async (args) => {
-      action(args);
-    });
-
     vi.clearAllMocks();
   });
 
@@ -65,21 +64,21 @@ describe("init command", () => {
 
   test("action is called", async () => {
     program.parse(["node", "test", "init"]);
-    expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith(defaultOptions);
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith(defaultOptions);
   });
 
   test("option --headless is accepted", async () => {
     program.parse(["node", "test", "init", "--headless"]);
-    expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true});
+    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(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
+    expect(InitAction).toHaveBeenCalledTimes(1);
+    expect(InitAction.prototype.execute).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/commands/up.test.ts

@@ -2,17 +2,9 @@ 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 { StartAction } from "../../src/commands/general/start";
 
-const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
-
-const action = vi.fn();
-const defaultOptions = {
-  resetValidators: false,
-  numValidators: "5",
-  headless: false ,
-  resetDb: false
-}
+vi.mock("../../src/commands/general/start");
 
 describe("up command", () => {
   let upCommand: Command;
@@ -23,10 +15,6 @@ describe("up command", () => {
     initializeGeneralCommands(program);
 
     upCommand = getCommand(program, "up");
-    upCommand?.action(async (args) => {
-      action(args);
-    });
-
     vi.clearAllMocks();
   });
 
@@ -36,6 +24,15 @@ describe("up command", () => {
 
   test("doesn't require arguments or options", async () => {
     expect(() => program.parse(["node", "test", "up"])).not.toThrow();
+    expect(StartAction).toHaveBeenCalledTimes(1);
+    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        resetValidators: false,
+        numValidators: "5",
+        headless: false,
+        resetDb: false,
+      })
+    );
   });
 
   test("option --reset-validators is accepted", async () => {
@@ -56,7 +53,6 @@ describe("up command", () => {
     expect(numValidatorsOption?.defaultValue).toBe("5");
   });
 
-
   test("unrecognized option is not accepted", async () => {
     upCommand?.exitOverride();
     expect(() => program.parse(["node", "test", "up", "-unknown"])).toThrowError(
@@ -69,8 +65,15 @@ describe("up command", () => {
 
   test("action is called with default options", async () => {
     program.parse(["node", "test", "up"]);
-    expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith(defaultOptions);
+    expect(StartAction).toHaveBeenCalledTimes(1);
+    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        resetValidators: false,
+        numValidators: "5",
+        headless: false,
+        resetDb: false,
+      })
+    );
   });
 
   test("action is called with custom options", async () => {
@@ -82,12 +85,17 @@ describe("up command", () => {
       "--numValidators",
       "10",
       "--headless",
-      "true",
-      "--reset-db",
-      "true"
+      "--reset-db"
     ]);
-    expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true, numValidators: '10', resetValidators: true, resetDb: true});
-    expect(openFrontendSpy).not.toHaveBeenCalled();
+
+    expect(StartAction).toHaveBeenCalledTimes(1);
+    expect(StartAction.prototype.execute).toHaveBeenCalledWith(
+      expect.objectContaining({
+        resetValidators: true,
+        numValidators: "10",
+        headless: true,
+        resetDb: true,
+      })
+    );
   });
 });

package/tests/commands/update.test.ts

@@ -2,10 +2,8 @@ import { Command } from "commander";
 import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeUpdateCommands } from "../../src/commands/update";
 import { OllamaAction } from "../../src/commands/update/ollama";
-import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
 
 vi.mock("../../src/commands/update/ollama");
-vi.mock("../../src/lib/config/ConfigFileManager");
 
 describe("ollama command", () => {
   let program: Command;
@@ -15,7 +13,6 @@ describe("ollama command", () => {
     initializeUpdateCommands(program);
 
     const mockConfig = { defaultOllamaModel: "default-model" };
-    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
   });
 
   afterEach(() => {
@@ -31,7 +28,7 @@ describe("ollama command", () => {
   test("OllamaAction.updateModel is called with default model", async () => {
     program.parse(["node", "test", "update", "ollama"]);
     expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.updateModel).toHaveBeenCalledWith("default-model");
+    expect(OllamaAction.prototype.updateModel).toHaveBeenCalledWith("");
   });
 
   test("OllamaAction.removeModel is called with model option", async () => {
@@ -43,6 +40,6 @@ describe("ollama command", () => {
   test("OllamaAction.removeModel is called with default model", async () => {
     program.parse(["node", "test", "update", "ollama", "--remove"]);
     expect(OllamaAction).toHaveBeenCalledTimes(1);
-    expect(OllamaAction.prototype.removeModel).toHaveBeenCalledWith("default-model");
+    expect(OllamaAction.prototype.removeModel).toHaveBeenCalledWith("");
   });
 });

package/tests/libs/baseAction.test.ts

@@ -0,0 +1,175 @@
+import {describe, test, vi, beforeEach, afterEach, expect, Mock} from "vitest";
+import { BaseAction } from "../../src/lib/actions/BaseAction";
+import inquirer from "inquirer";
+import ora, { Ora } from "ora";
+import chalk from "chalk";
+
+vi.mock("inquirer");
+vi.mock("ora");
+
+describe("BaseAction", () => {
+  let baseAction: BaseAction;
+  let mockSpinner: Ora;
+  let consoleSpy: any;
+  let consoleErrorSpy: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    mockSpinner = {
+      start: vi.fn(),
+      stop: vi.fn(),
+      succeed: vi.fn(),
+      fail: vi.fn(),
+      text: "",
+    } as unknown as Ora;
+
+    (ora as unknown as Mock).mockReturnValue(mockSpinner);
+
+    baseAction = new BaseAction();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("should start the spinner with a message", () => {
+    baseAction["startSpinner"]("Loading...");
+    expect(mockSpinner.start).toHaveBeenCalled();
+    expect(mockSpinner.text).toBe(chalk.blue("Loading..."));
+  });
+
+  test("should succeed the spinner with a message", () => {
+    baseAction["succeedSpinner"]("Success");
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
+  });
+
+  test("should fail the spinner with an error message", () => {
+    baseAction["failSpinner"]("Failure", new Error("Something went wrong"));
+    expect(mockSpinner.fail).toHaveBeenCalledWith(expect.stringContaining("Failure"));
+  });
+
+  test("should stop the spinner", () => {
+    baseAction["stopSpinner"]();
+    expect(mockSpinner.stop).toHaveBeenCalled();
+  });
+
+  test("should set spinner text", () => {
+    baseAction["setSpinnerText"]("Updated text");
+    expect(mockSpinner.text).toBe(chalk.blue("Updated text"));
+  });
+
+  test("should confirm prompt and proceed when confirmed", async () => {
+    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 });
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process exited");
+    });
+
+    await expect(baseAction["confirmPrompt"]("Are you sure?")).rejects.toThrow("process exited");
+    expect(inquirer.prompt).toHaveBeenCalled();
+    expect(processExitSpy).toHaveBeenCalledWith(0);
+  });
+
+  test("should log a success message", () => {
+    baseAction["logSuccess"]("Success message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
+  });
+
+  test("should log an error message", () => {
+    baseAction["logError"]("Error message");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("✖ Error message"));
+  });
+
+  test("should log a info message", () => {
+    baseAction["logInfo"]("Info message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
+  });
+
+  test("should log a warning message", () => {
+    baseAction["logWarning"]("Warning message");
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
+  });
+
+  test("should log a success message with data", () => {
+    const data = { key: "value" };
+
+    baseAction["logSuccess"]("Success message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("✔ Success message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.green(JSON.stringify(data, null, 2)));
+  });
+
+  test("should log an error message with error details", () => {
+    const error = new Error("Something went wrong");
+
+    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)));
+  });
+
+  test("should log an info message with data", () => {
+    const data = { info: "This is some info" };
+
+    baseAction["logInfo"]("Info message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("ℹ Info message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.blue(JSON.stringify(data, null, 2)));
+  });
+
+  test("should log a warning message with data", () => {
+    const data = { warning: "This is a warning" };
+
+    baseAction["logWarning"]("Warning message", data);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("⚠ Warning message"));
+    expect(consoleSpy).toHaveBeenCalledWith(chalk.yellow(JSON.stringify(data, null, 2)));
+  });
+
+  test("should succeed the spinner with a message and log result if data is provided", () => {
+    const mockData = { key: "value" };
+
+    baseAction["succeedSpinner"]("Success", mockData);
+
+    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Result:"));
+    expect(consoleSpy).toHaveBeenCalledWith(JSON.stringify(mockData, null, 2));
+    expect(mockSpinner.succeed).toHaveBeenCalledWith(expect.stringContaining("Success"));
+  });
+
+  test("should format an Error instance with name, message, and additional properties", () => {
+    const error = new Error("Something went wrong");
+    (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));
+  });
+
+  test("should format an object as JSON string", () => {
+    const data = { key: "value", num: 42 };
+    const result = (baseAction as any).formatOutput(data);
+
+    expect(result).toBe(JSON.stringify(data, null, 2));
+  });
+
+  test("should return a string representation of a primitive", () => {
+    expect((baseAction as any).formatOutput("Hello")).toBe("Hello");
+    expect((baseAction as any).formatOutput(42)).toBe("42");
+    expect((baseAction as any).formatOutput(true)).toBe("true");
+  });
+
+});

package/tests/services/simulator.test.ts

@@ -282,6 +282,21 @@ describe("SimulatorService - Basic Tests", () => {
     expect(rpcClient.request).toHaveBeenCalledWith({ method: "sim_clearDbTables", params: [['current_state', 'transactions']] });
   });
 
+  test("should create random validators", async () => {
+    const numValidators = 5;
+    const llmProviders = ["openai", "ollama"];
+    const mockResponse = { success: true };
+    vi.mocked(rpcClient.request).mockResolvedValue(mockResponse);
+
+    const result = await simulatorService.createRandomValidators(numValidators, llmProviders);
+
+    expect(rpcClient.request).toHaveBeenCalledWith({
+      method: "sim_createRandomValidators",
+      params: [numValidators, 1, 10, llmProviders],
+    });
+    expect(result).toEqual(mockResponse);
+  });
+
 });
 describe("SimulatorService - Docker Tests", () => {
   let mockGetContainer: Mock;

package/.eslintrc.js

@@ -1,58 +0,0 @@
-module.exports = {
-  root: true,
-  env: {
-    es6: true,
-    node: true,
-    jest: true,
-  },
-  extends: ["eslint:recommended", "prettier", "plugin:import/typescript"],
-  parser: "@typescript-eslint/parser",
-  plugins: ["@typescript-eslint", "import"],
-  overrides: [
-    {
-      files: "**/*.ts",
-      parserOptions: {
-        project: ["./tsconfig.json"],
-        sourceType: "module",
-      },
-      extends: [
-        "plugin:import/errors",
-        "plugin:import/warnings",
-        "plugin:import/typescript",
-        "plugin:@typescript-eslint/recommended",
-      ],
-      rules: {
-        "import/namespace": "off",
-        "@typescript-eslint/no-empty-function": "off",
-        "@typescript-eslint/no-empty-interface": "off",
-        "no-constant-condition": "off",
-        "@typescript-eslint/no-explicit-any": "off",
-        "prefer-const": "off",
-        "@typescript-eslint/no-non-null-assertion": "off",
-        "@typescript-eslint/ban-ts-ignore": "off",
-        "@typescript-eslint/no-loss-of-precision": "off",
-        "@typescript-eslint/ban-types": "off",
-        "@typescript-eslint/ban-ts-comment": "off",
-        "@typescript-eslint/no-non-null-asserted-optional-chain": "off",
-        "@typescript-eslint/no-var-requires": "off",
-        "import/export": "off",
-        "no-fallthrough": "off",
-        "@typescript-eslint/explicit-module-boundary-types": "off",
-        "@typescript-eslint/no-floating-promises": ["error"],
-        "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
-      },
-    },
-  ],
-  ignorePatterns: [
-    "**/dist/**/*", // Ignore built files.
-    "esbuild.config.js",
-    "jest.config.js",
-    "Config.js",
-    "commitLint.config.ts",
-  ],
-  settings: {
-    "import/resolver": {
-      typescript: {},
-    },
-  },
-};

package/esbuild.config.dev

@@ -1,16 +0,0 @@
-module.exports = {
-  context: {
-    tsconfig: "./tsconfig.json",
-    entryPoints: ["src/index.ts"],
-    bundle: true, // Bundle all dependencies
-    outfile: "dist/index.js", // Output file
-    platform: "node",
-    target: "es2020",
-    define: { 'import.meta.url': '_importMetaUrl' },
-    banner: {
-      js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
-    },
-    external: ['ssh2'],
-  },
-  watch: true,
-};

package/esbuild.config.prod

@@ -1,16 +0,0 @@
-module.exports = {
-  context: {
-    tsconfig: "./tsconfig.json",
-    entryPoints: ["src/index.ts"],
-    bundle: true, // Bundle all dependencies
-    outfile: "dist/index.js", // Output file
-    platform: "node",
-    target: "es2020",
-    define: { 'import.meta.url': '_importMetaUrl' },
-    banner: {
-      js: "const _importMetaUrl=require('url').pathToFileURL(__filename)",
-    },
-    external: ['ssh2'],
-  },
-  watch: false,
-};