genlayer 0.18.1 → 0.18.2-beta.0

package/tests/services/simulator.test.ts

@@ -1,29 +1,27 @@
-import { describe, beforeEach, test, expect, vi, Mock } from "vitest";
+import {describe, beforeEach, test, expect, vi, Mock} from "vitest";
 import * as path from "path";
 import * as fs from "fs";
 import * as dotenv from "dotenv";
 import simulatorService from "../../src/lib/services/simulator";
-import {
-  getVersion,
-  executeCommand,
-  openUrl,
-  checkCommand,
-} from "../../src/lib/clients/system";
+import {getVersion, executeCommand, openUrl, checkCommand} from "../../src/lib/clients/system";
 import {
   CONTAINERS_NAME_PREFIX,
   VERSION_REQUIREMENTS,
   STARTING_TIMEOUT_ATTEMPTS,
-  DEFAULT_RUN_SIMULATOR_COMMAND, localnetCompatibleVersion, IMAGES_NAME_PREFIX,
-  AiProviders, GENLAYER_REQUIRED_CONTAINERS,
+  DEFAULT_RUN_SIMULATOR_COMMAND,
+  localnetCompatibleVersion,
+  IMAGES_NAME_PREFIX,
+  AiProviders,
+  GENLAYER_REQUIRED_CONTAINERS,
 } from "../../src/lib/config/simulator";
-import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
+import {rpcClient} from "../../src/lib/clients/jsonRpcClient";
 import * as semver from "semver";
 import Docker from "dockerode";
 import {VersionRequiredError} from "../../src/lib/errors/versionRequired";
 import updateCheck from "update-check";
 
 vi.mock("../../package.json", () => ({
-  default: { version: "1.0.0", name: "genlayer" },
+  default: {version: "1.0.0", name: "genlayer"},
 }));
 
 vi.mock("update-check", () => ({
@@ -58,10 +56,9 @@ describe("SimulatorService - Basic Tests", () => {
     vi.mocked(path.join).mockImplementation((...args) => args.join("/"));
   });
 
-
   test("should read the correct frontend URL from .env config", () => {
     const mockEnvContent = "FRONTEND_PORT=8080";
-    const mockEnvConfig = { FRONTEND_PORT: "8080" };
+    const mockEnvConfig = {FRONTEND_PORT: "8080"};
     vi.mocked(fs.readFileSync).mockReturnValue(mockEnvContent);
     vi.mocked(dotenv.parse).mockReturnValue(mockEnvConfig);
     const frontendUrl = simulatorService.getFrontendUrl();
@@ -85,39 +82,38 @@ describe("SimulatorService - Basic Tests", () => {
     await expect(simulatorService.checkVersion("14.0.0", "node")).rejects.toThrow();
   });
 
-
   test("should return initialized true when simulator responds with OK (result.status = OK)", async () => {
-    vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: {status: 'OK'} });
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({result: {status: "OK"}});
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
-    expect(result).toEqual({ initialized: true });
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
+    expect(result).toEqual({initialized: true});
+    expect(rpcClient.request).toHaveBeenCalledWith({method: "ping", params: []});
   });
 
   test("should return initialized true when simulator responds with OK (result.data.status = OK)", async () => {
-    vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: {data: {status: 'OK'}} });
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({result: {data: {status: "OK"}}});
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
-    expect(result).toEqual({ initialized: true });
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
+    expect(result).toEqual({initialized: true});
+    expect(rpcClient.request).toHaveBeenCalledWith({method: "ping", params: []});
   });
 
   test("should return initialized true when simulator responds with OK (result = OK)", async () => {
-    vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: 'OK' });
+    vi.mocked(rpcClient.request).mockResolvedValueOnce({result: "OK"});
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
-    expect(result).toEqual({ initialized: true });
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "ping", params: [] });
+    expect(result).toEqual({initialized: true});
+    expect(rpcClient.request).toHaveBeenCalledWith({method: "ping", params: []});
   });
 
   test("should return initialized false with errorCode TIMEOUT after retries", async () => {
     vi.mocked(rpcClient.request).mockResolvedValue(undefined);
     const result = await simulatorService.waitForSimulatorToBeReady(1);
-    expect(result).toEqual({ initialized: false, errorCode: "TIMEOUT" });
+    expect(result).toEqual({initialized: false, errorCode: "TIMEOUT"});
   });
 
   test("should return initialized false with errorCode ERROR on non-retryable error", async () => {
     const nonRetryableError = new Error("Unexpected error");
     vi.mocked(rpcClient.request).mockRejectedValue(nonRetryableError);
     const result = await simulatorService.waitForSimulatorToBeReady(STARTING_TIMEOUT_ATTEMPTS);
-    expect(result).toEqual({ initialized: false, errorCode: "ERROR", errorMessage: nonRetryableError.message });
+    expect(result).toEqual({initialized: false, errorCode: "ERROR", errorMessage: nonRetryableError.message});
   });
 
   test("should execute the correct run simulator command based on simulator location", async () => {
@@ -126,9 +122,9 @@ describe("SimulatorService - Basic Tests", () => {
       stderr: "",
     });
     const result = await simulatorService.runSimulator();
-    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorService.location, '');
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorService.location, "");
     expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
-    expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
+    expect(result).toEqual({stdout: "Simulator started", stderr: ""});
   });
 
   test("should execute the correct run simulator command based on headless option", async () => {
@@ -136,12 +132,12 @@ describe("SimulatorService - Basic Tests", () => {
       stdout: "Simulator started",
       stderr: "",
     });
-    simulatorService.setComposeOptions(true)
+    simulatorService.setComposeOptions(true);
     const commandOption = simulatorService.getComposeOptions();
     const result = await simulatorService.runSimulator();
     const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorService.location, commandOption);
     expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
-    expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
+    expect(result).toEqual({stdout: "Simulator started", stderr: ""});
   });
 
   test("should execute the correct run simulator command based on ollama option", async () => {
@@ -174,8 +170,8 @@ describe("SimulatorService - Basic Tests", () => {
   test("should create a backup of the .env file and add new config", () => {
     const envFilePath = `/.env`;
     const originalEnvContent = "KEY1=value1\nKEY2=value2";
-    const parsedEnvConfig = { KEY1: "value1", KEY2: "value2" };
-    const newConfig = { KEY3: "value3", KEY2: "newValue2" };
+    const parsedEnvConfig = {KEY1: "value1", KEY2: "value2"};
+    const newConfig = {KEY3: "value3", KEY2: "newValue2"};
 
     vi.mocked(fs.readFileSync).mockImplementation((filePath: any) => {
       if (filePath === envFilePath) return originalEnvContent;
@@ -193,7 +189,7 @@ describe("SimulatorService - Basic Tests", () => {
 
   test("should handle empty .env file and add new config", () => {
     const envFilePath = `/.env`;
-    const newConfig = { NEW_KEY: "newValue" };
+    const newConfig = {NEW_KEY: "newValue"};
 
     vi.mocked(fs.readFileSync).mockReturnValue("");
     vi.mocked(dotenv.parse).mockReturnValue({});
@@ -210,12 +206,9 @@ describe("SimulatorService - Basic Tests", () => {
       throw new Error("File not found");
     });
 
-    expect(() => simulatorService.addConfigToEnvFile({ KEY: "value" })).toThrow(
-      "File not found"
-    );
+    expect(() => simulatorService.addConfigToEnvFile({KEY: "value"})).toThrow("File not found");
   });
 
-
   test("should open the frontend URL and return true", async () => {
     vi.spyOn(simulatorService, "getFrontendUrl").mockReturnValue("http://localhost:8080");
     const result = await simulatorService.openFrontend();
@@ -225,35 +218,31 @@ describe("SimulatorService - Basic Tests", () => {
   });
 
   test("should call rpcClient.request with correct parameters and return the response", async () => {
-    const mockResponse = { success: true };
+    const mockResponse = {success: true};
     vi.mocked(rpcClient.request).mockResolvedValue(mockResponse);
     const result = await simulatorService.deleteAllValidators();
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "sim_deleteAllValidators", params: [] });
+    expect(rpcClient.request).toHaveBeenCalledWith({method: "sim_deleteAllValidators", params: []});
     expect(result).toBe(mockResponse);
   });
 
   test("should return node missing version", async () => {
-    const unexpectedError = new VersionRequiredError('node', VERSION_REQUIREMENTS.node);
-    vi.spyOn(simulatorService, "checkVersion")
-      .mockRejectedValueOnce(unexpectedError)
-      .mockResolvedValueOnce();
+    const unexpectedError = new VersionRequiredError("node", VERSION_REQUIREMENTS.node);
+    vi.spyOn(simulatorService, "checkVersion").mockRejectedValueOnce(unexpectedError).mockResolvedValueOnce();
 
     await expect(simulatorService.checkVersionRequirements()).resolves.toStrictEqual({
-      "docker": "",
-      "node": VERSION_REQUIREMENTS.node
-    })
+      docker: "",
+      node: VERSION_REQUIREMENTS.node,
+    });
   });
 
   test("should return docker missing version", async () => {
-    const unexpectedError = new VersionRequiredError('node', VERSION_REQUIREMENTS.docker);
-    vi.spyOn(simulatorService, "checkVersion")
-      .mockResolvedValueOnce()
-      .mockRejectedValueOnce(unexpectedError)
+    const unexpectedError = new VersionRequiredError("node", VERSION_REQUIREMENTS.docker);
+    vi.spyOn(simulatorService, "checkVersion").mockResolvedValueOnce().mockRejectedValueOnce(unexpectedError);
 
     await expect(simulatorService.checkVersionRequirements()).resolves.toStrictEqual({
-      "docker": VERSION_REQUIREMENTS.docker,
-      "node": ""
-    })
+      docker: VERSION_REQUIREMENTS.docker,
+      node: "",
+    });
   });
 
   test("should throw an unexpected error when checking node version requirements", async () => {
@@ -272,14 +261,14 @@ describe("SimulatorService - Basic Tests", () => {
   test("should throw an unexpected error when checking git installation requirement", async () => {
     vi.mocked(checkCommand).mockRejectedValueOnce(new Error("Unexpected git error"));
     await expect(simulatorService.checkInstallRequirements()).rejects.toThrow("Unexpected git error");
-    const requirementsInstalled = { git: false, docker: false };
+    const requirementsInstalled = {git: false, docker: false};
     expect(requirementsInstalled.git).toBe(false);
   });
 
   test("should retry when response is not 'OK' and reach sleep path", async () => {
-    vi.mocked(rpcClient.request).mockResolvedValue({ result: { status: "NOT_OK" } });
+    vi.mocked(rpcClient.request).mockResolvedValue({result: {status: "NOT_OK"}});
     const result = await simulatorService.waitForSimulatorToBeReady(1);
-    expect(result).toEqual({ initialized: false, errorCode: "TIMEOUT" });
+    expect(result).toEqual({initialized: false, errorCode: "TIMEOUT"});
   });
 
   test("should retry on fetch error and reach sleep path", async () => {
@@ -287,18 +276,16 @@ describe("SimulatorService - Basic Tests", () => {
     fetchError.name = "FetchError";
     vi.mocked(rpcClient.request).mockRejectedValue(fetchError);
     const result = await simulatorService.waitForSimulatorToBeReady(1);
-    expect(result).toEqual({ initialized: false, errorCode: "ERROR", errorMessage: fetchError.message });
+    expect(result).toEqual({initialized: false, errorCode: "ERROR", errorMessage: fetchError.message});
   });
 
   test("should call executeCommand if docker ps command fails", async () => {
-    vi.mocked(checkCommand)
-      .mockResolvedValueOnce(undefined)
+    vi.mocked(checkCommand).mockResolvedValueOnce(undefined);
 
     const result = await simulatorService.checkInstallRequirements();
     expect(result.docker).toBe(true);
   });
 
-
   test("should return providers without errors", () => {
     expect(simulatorService.getAiProvidersOptions(true)).toEqual(expect.any(Array));
     expect(simulatorService.getAiProvidersOptions(false)).toEqual(expect.any(Array));
@@ -331,15 +318,18 @@ describe("SimulatorService - Basic Tests", () => {
   });
 
   test("clean simulator should success", async () => {
-    vi.mocked(rpcClient.request).mockResolvedValueOnce('Success');
+    vi.mocked(rpcClient.request).mockResolvedValueOnce("Success");
     await expect(simulatorService.cleanDatabase).not.toThrow();
-    expect(rpcClient.request).toHaveBeenCalledWith({ method: "sim_clearDbTables", params: [['current_state', 'transactions']] });
+    expect(rpcClient.request).toHaveBeenCalledWith({
+      method: "sim_clearDbTables",
+      params: [["current_state", "transactions"]],
+    });
   });
 
   test("should create random validators", async () => {
     const numValidators = 5;
     const llmProviders = ["openai", "ollama"] as AiProviders[];
-    const mockResponse = { success: true };
+    const mockResponse = {success: true};
     vi.mocked(rpcClient.request).mockResolvedValue(mockResponse);
 
     const result = await simulatorService.createRandomValidators(numValidators, llmProviders);
@@ -350,7 +340,6 @@ describe("SimulatorService - Basic Tests", () => {
     });
     expect(result).toEqual(mockResponse);
   });
-
 });
 describe("SimulatorService - Docker Tests", () => {
   let mockGetContainer: Mock;
@@ -370,11 +359,11 @@ describe("SimulatorService - Docker Tests", () => {
 
   test("isLocalnetRunning should return true when all required containers are running", async () => {
     const mockContainers = [
-      { Id: "container1", Names: ["/genlayer-jsonrpc1"], State: "running" },
-      { Id: "container2", Names: ["/genlayer-webrequest1"], State: "running" },
-      { Id: "container3", Names: ["/genlayer-postgres1"], State: "running" },
-      { Id: "container4", Names: ["/genlayer-other-container1"], State: "running" },
-      { Id: "container5", Names: ["/genlayer-another-container1"], State: "exited" }
+      {Id: "container1", Names: ["/genlayer-jsonrpc1"], State: "running"},
+      {Id: "container2", Names: ["/genlayer-webrequest1"], State: "running"},
+      {Id: "container3", Names: ["/genlayer-postgres1"], State: "running"},
+      {Id: "container4", Names: ["/genlayer-other-container1"], State: "running"},
+      {Id: "container5", Names: ["/genlayer-another-container1"], State: "exited"},
     ];
 
     mockListContainers.mockResolvedValue(mockContainers);
@@ -384,11 +373,11 @@ describe("SimulatorService - Docker Tests", () => {
 
   test("isLocalnetRunning should return false when not all required containers are running", async () => {
     const mockContainers = [
-      { Id: "container1", Names: ["/genlayer-jsonrpc2"], State: "running" },
-      { Id: "container2", Names: ["/genlayer-webrequest2"], State: "running" },
-      { Id: "container3", Names: ["/genlayer-postgres2"], State: "exited" },
-      { Id: "container4", Names: ["/genlayer-other-container2"], State: "running" },
-      { Id: "container5", Names: ["/unrelated-container2"], State: "running" }
+      {Id: "container1", Names: ["/genlayer-jsonrpc2"], State: "running"},
+      {Id: "container2", Names: ["/genlayer-webrequest2"], State: "running"},
+      {Id: "container3", Names: ["/genlayer-postgres2"], State: "exited"},
+      {Id: "container4", Names: ["/genlayer-other-container2"], State: "running"},
+      {Id: "container5", Names: ["/unrelated-container2"], State: "running"},
     ];
 
     mockListContainers.mockResolvedValue(mockContainers);
@@ -419,15 +408,18 @@ describe("SimulatorService - Docker Tests", () => {
 
     const mockStop = vi.fn().mockResolvedValue(undefined);
     const mockRemove = vi.fn().mockResolvedValue(undefined);
-    mockGetContainer.mockImplementation(() => ({
-      stop: mockStop,
-      remove: mockRemove,
-    } as unknown as Docker.Container));
+    mockGetContainer.mockImplementation(
+      () =>
+        ({
+          stop: mockStop,
+          remove: mockRemove,
+        }) as unknown as Docker.Container,
+    );
 
     const result = await simulatorService.resetDockerContainers();
 
     expect(result).toBe(undefined);
-    expect(mockListContainers).toHaveBeenCalledWith({ all: true });
+    expect(mockListContainers).toHaveBeenCalledWith({all: true});
 
     // Ensure only the relevant containers were stopped and removed
     expect(mockGetContainer).toHaveBeenCalledWith("container1");
@@ -456,9 +448,12 @@ describe("SimulatorService - Docker Tests", () => {
 
     const mockStop = vi.fn().mockResolvedValue(undefined);
     const mockGetContainer = vi.mocked(Docker.prototype.getContainer);
-    mockGetContainer.mockImplementation(() => ({
-      stop: mockStop,
-    } as unknown as Docker.Container));
+    mockGetContainer.mockImplementation(
+      () =>
+        ({
+          stop: mockStop,
+        }) as unknown as Docker.Container,
+    );
 
     await simulatorService.stopDockerContainers();
 
@@ -467,7 +462,6 @@ describe("SimulatorService - Docker Tests", () => {
     expect(mockStop).toHaveBeenCalledTimes(1);
   });
 
-
   test("should remove Docker images with the specified prefix", async () => {
     const mockImages = [
       {
@@ -487,9 +481,12 @@ describe("SimulatorService - Docker Tests", () => {
     mockListImages.mockResolvedValue(mockImages);
 
     const mockRemove = vi.fn().mockResolvedValue(undefined);
-    mockGetImage.mockImplementation(() => ({
-      remove: mockRemove,
-    } as unknown as Docker.Image));
+    mockGetImage.mockImplementation(
+      () =>
+        ({
+          remove: mockRemove,
+        }) as unknown as Docker.Image,
+    );
 
     const result = await simulatorService.resetDockerImages();
 
@@ -499,12 +496,11 @@ describe("SimulatorService - Docker Tests", () => {
     expect(mockGetImage).toHaveBeenCalledWith("image2");
     expect(mockGetImage).not.toHaveBeenCalledWith("image3");
     expect(mockRemove).toHaveBeenCalledTimes(2);
-    expect(mockRemove).toHaveBeenCalledWith({ force: true });
+    expect(mockRemove).toHaveBeenCalledWith({force: true});
   });
 
   test("should execute command when docker is installed but is not available", async () => {
-    vi.mocked(checkCommand)
-      .mockResolvedValueOnce(undefined)
+    vi.mocked(checkCommand).mockResolvedValueOnce(undefined);
 
     mockPing.mockRejectedValueOnce("");
     await simulatorService.checkInstallRequirements();
@@ -512,15 +508,13 @@ describe("SimulatorService - Docker Tests", () => {
   });
 
   test("should call execute command again to start docker service", async () => {
-    vi.mocked(checkCommand)
-      .mockResolvedValueOnce(undefined)
-      .mockRejectedValue(undefined);
+    vi.mocked(checkCommand).mockResolvedValueOnce(undefined).mockRejectedValue(undefined);
     mockPing.mockRejectedValueOnce("");
-    await expect(simulatorService.checkInstallRequirements()).resolves.toStrictEqual({ docker: true });
+    await expect(simulatorService.checkInstallRequirements()).resolves.toStrictEqual({docker: true});
   });
 
   test("should warn the user when an update is available", async () => {
-    const update = { latest: "1.1.0" };
+    const update = {latest: "1.1.0"};
     (updateCheck as any).mockResolvedValue(update);
 
     const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
@@ -528,14 +522,14 @@ describe("SimulatorService - Docker Tests", () => {
     await simulatorService.checkCliVersion();
 
     expect(consoleWarnSpy).toHaveBeenCalledWith(
-      `\nA new version (${update.latest}) is available! You're using version 1.0.0.\nRun npm install -g genlayer to update\n`
+      `\nA new version (${update.latest}) is available! You're using version 1.0.0.\nRun npm install -g genlayer to update\n`,
     );
 
     consoleWarnSpy.mockRestore();
   });
 
   test("should not warn the user when the CLI is up-to-date", async () => {
-    const update = { latest: "1.0.0" };
+    const update = {latest: "1.0.0"};
     (updateCheck as any).mockResolvedValue(update);
 
     const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
@@ -560,7 +554,7 @@ describe("SimulatorService - Docker Tests", () => {
   });
 });
 
-describe('normalizeLocalnetVersion', () => {
+describe("normalizeLocalnetVersion", () => {
   test('should add "v" if not present', () => {
     expect(simulatorService.normalizeLocalnetVersion("0.26.0")).toBe("v0.26.0");
   });
@@ -574,18 +568,20 @@ describe('normalizeLocalnetVersion', () => {
     expect(simulatorService.normalizeLocalnetVersion("v1.0.0-alpha")).toBe("v1.0.0-alpha");
   });
 
-  test('should handle versions with numbers only', () => {
+  test("should handle versions with numbers only", () => {
     expect(simulatorService.normalizeLocalnetVersion("1.0.0")).toBe("v1.0.0");
   });
 
-  test('should throw an error and exit for invalid versions', () => {
-    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => { return undefined as never});
-    const mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+  test("should throw an error and exit for invalid versions", () => {
+    const mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
+      return undefined as never;
+    });
+    const mockConsoleError = vi.spyOn(console, "error").mockImplementation(() => {});
 
     simulatorService.normalizeLocalnetVersion("invalid-version");
 
     expect(mockConsoleError).toHaveBeenCalledWith(
-      'Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix'
+      "Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix",
     );
     expect(mockExit).toHaveBeenCalledWith(1);
 
@@ -602,7 +598,7 @@ describe('normalizeLocalnetVersion', () => {
 
     expect(rpcClient.request).toHaveBeenCalledWith({
       method: "sim_clearDbTables",
-      params: [['current_state', 'transactions']],
+      params: [["current_state", "transactions"]],
     });
     expect(console.error).toHaveBeenCalledWith(mockError);
   });