genlayer 0.10.1 → 0.11.0

package/tests/commands/validator.test.ts

@@ -0,0 +1,127 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeValidatorCommands } from "../../src/commands/validators";
+import { ValidatorsAction } from "../../src/commands/validators/validators";
+
+vi.mock("../../src/commands/validators/validators");
+
+describe("validators 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", "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", "validators", "get"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.getValidator).toHaveBeenCalledWith({});
+  });
+
+  test("ValidatorsAction.deleteValidator is called with address option", async () => {
+    program.parse(["node", "test", "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", "validators", "delete"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.deleteValidator).toHaveBeenCalledWith({});
+  });
+
+  test("ValidatorsAction.countValidators is called", async () => {
+    program.parse(["node", "test", "validators", "count"]);
+    expect(ValidatorsAction).toHaveBeenCalledTimes(1);
+    expect(ValidatorsAction.prototype.countValidators).toHaveBeenCalled();
+  });
+
+  test("ValidatorsAction.updateValidator is called with all options", async () => {
+    program.parse([
+      "node",
+      "test",
+      "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",
+      "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", "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",
+      "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/index.test.ts

@@ -25,6 +25,10 @@ vi.mock("../src/commands/config", () => ({
   initializeConfigCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/validators", () => ({
+  initializeValidatorCommands: vi.fn(),
+}));
+
 vi.mock("../src/commands/update", () => ({
   initializeUpdateCommands: vi.fn(),
 }));

package/tests/libs/jsonRpcClient.test.ts

@@ -40,6 +40,7 @@ describe("JsonRpcClient - Successful and Unsuccessful Requests", () => {
   test("should return null when the fetch response is not ok", async () => {
     (fetch as Mock).mockResolvedValueOnce({
       ok: false,
+      statusText: "Something went wrong",
       json: async () => ({ error: "Something went wrong" }),
     });
 
@@ -48,9 +49,7 @@ describe("JsonRpcClient - Successful and Unsuccessful Requests", () => {
       params: ["param1", "param2"],
     };
 
-    const response = await rpcClient.request(params);
-
-    expect(response).toBeNull();
+    await expect(rpcClient.request(params)).rejects.toThrowError("Something went wrong");
     expect(fetch).toHaveBeenCalledWith(mockServerUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },

package/tests/services/simulator.test.ts

@@ -200,7 +200,7 @@ describe("SimulatorService - Basic Tests", () => {
     const mockResponse = { success: true };
     vi.mocked(rpcClient.request).mockResolvedValue(mockResponse);
     const result = await simulatorService.deleteAllValidators();
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "delete_all_validators", params: [] });
+    expect(rpcClient.request).toHaveBeenCalledWith({ method: "sim_deleteAllValidators", params: [] });
     expect(result).toBe(mockResponse);
   });
 
@@ -465,4 +465,18 @@ describe('normalizeLocalnetVersion', () => {
     mockExit.mockRestore();
     mockConsoleError.mockRestore();
   });
+  test("should log an error if an exception occurs while cleaning the database", async () => {
+    const mockError = new Error("Database cleanup error");
+    vi.mocked(rpcClient.request).mockRejectedValue(mockError);
+
+    console.error = vi.fn();
+
+    await simulatorService.cleanDatabase();
+
+    expect(rpcClient.request).toHaveBeenCalledWith({
+      method: "sim_clearDbTables",
+      params: [['current_state', 'transactions']],
+    });
+    expect(console.error).toHaveBeenCalledWith(mockError);
+  });
 });