genlayer 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 
 
+## 0.1.3 (2024-11-08)
+
+## 0.1.2 (2024-11-08)
+
 ## 0.1.1 (2024-11-08)
 
 ## 0.1.0 (2024-11-08)

package/dist/index.js

@@ -39699,7 +39699,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.1.1";
+var version = "0.1.3";
 
 // src/lib/config/text.ts
 var CLI_DESCRIPTION = "GenLayer CLI is a development environment for the GenLayer ecosystem. It allows developers to interact with the protocol by creating accounts, sending transactions, and working with Intelligent Contracts by testing, debugging, and deploying them.";
@@ -40302,23 +40302,24 @@ var MissingRequirementError = class extends Error {
 };
 
 // src/lib/clients/system.ts
-var asyncExec = import_node_util5.default.promisify(import_child_process.exec);
 function checkCommand(command, toolName) {
   return __async(this, null, function* () {
-    const { stderr } = yield asyncExec(command);
+    const { stderr } = yield import_node_util5.default.promisify(import_child_process.exec)(command);
     if (stderr) {
       throw new MissingRequirementError(toolName);
     }
   });
 }
 function executeCommand(cmdsByPlatform, toolName) {
-  const runningPlatform = getPlatform();
-  const command = cmdsByPlatform[runningPlatform];
-  try {
-    return asyncExec(command);
-  } catch (error) {
-    throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
-  }
+  return __async(this, null, function* () {
+    const runningPlatform = getPlatform();
+    const command = cmdsByPlatform[runningPlatform];
+    try {
+      return yield import_node_util5.default.promisify(import_child_process.exec)(command);
+    } catch (error) {
+      throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
+    }
+  });
 }
 function getPlatform() {
   const currentPlatform = process.platform;
@@ -40333,7 +40334,7 @@ function openUrl(url) {
 function getVersion(toolName) {
   return __async(this, null, function* () {
     try {
-      const toolResponse = yield asyncExec(`${toolName} --version`);
+      const toolResponse = yield import_node_util5.default.promisify(import_child_process.exec)(`${toolName} --version`);
       if (toolResponse.stderr) {
         throw new Error(toolResponse.stderr);
       }
@@ -40354,31 +40355,29 @@ function getVersion(toolName) {
 function listDockerContainers() {
   return __async(this, null, function* () {
     try {
-      const dockerResponse = yield asyncExec("docker ps -a --format '{{.Names}}'");
+      const dockerResponse = yield import_node_util5.default.promisify(import_child_process.exec)("docker ps -a --format '{{.Names}}'");
       const dockerContainers = dockerResponse.stdout.split("\n");
       return dockerContainers;
     } catch (error) {
       throw new Error("Error listing Docker containers.");
     }
-    return [];
   });
 }
 function listDockerImages() {
   return __async(this, null, function* () {
     try {
-      const dockerResponse = yield asyncExec("docker images --format '{{.Repository}}'");
+      const dockerResponse = yield import_node_util5.default.promisify(import_child_process.exec)("docker images --format '{{.Repository}}'");
       const dockerImages = dockerResponse.stdout.split("\n");
       return dockerImages;
     } catch (error) {
       throw new Error("Error listing Docker images.");
     }
-    return [];
   });
 }
 function stopDockerContainer(containerName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker stop ${containerName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker stop ${containerName}`);
     } catch (error) {
       throw new Error(`Error stopping Docker container ${containerName}.`);
     }
@@ -40387,7 +40386,7 @@ function stopDockerContainer(containerName) {
 function removeDockerContainer(containerName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker rm ${containerName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker rm ${containerName}`);
     } catch (error) {
       throw new Error(`Error removing container ${containerName}.`);
     }
@@ -40396,7 +40395,7 @@ function removeDockerContainer(containerName) {
 function removeDockerImage(imageName) {
   return __async(this, null, function* () {
     try {
-      yield asyncExec(`docker rmi ${imageName}`);
+      yield import_node_util5.default.promisify(import_child_process.exec)(`docker rmi ${imageName}`);
     } catch (error) {
       throw new Error(`Error removing image ${imageName}.`);
     }
@@ -40569,10 +40568,11 @@ var SimulatorService = class {
   }
   waitForSimulatorToBeReady() {
     return __async(this, arguments, function* (retries = STARTING_TIMEOUT_ATTEMPTS) {
+      var _a, _b, _c;
       console.log("Waiting for the simulator to start up...");
       try {
         const response = yield rpcClient.request({ method: "ping", params: [] });
-        if (response && (response.result.status === "OK" || response.result.data.status === "OK")) {
+        if (((_a = response == null ? void 0 : response.result) == null ? void 0 : _a.status) === "OK" || ((_c = (_b = response == null ? void 0 : response.result) == null ? void 0 : _b.data) == null ? void 0 : _c.status) === "OK") {
           return { initialized: true };
         }
         if (retries > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genlayer",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "GenLayer Command Line Tool",
   "main": "src/index.ts",
   "bin": {

package/src/lib/clients/system.ts

@@ -4,12 +4,9 @@ import open from "open";
 
 import {RunningPlatform, AVAILABLE_PLATFORMS} from "../config/simulator";
 import {MissingRequirementError} from "../errors/missingRequirement";
-import {VersionRequiredError} from "../errors/versionRequired";
-
-const asyncExec = util.promisify(exec);
 
 export async function checkCommand(command: string, toolName: string): Promise<void> {
-  const {stderr} = await asyncExec(command);
+  const {stderr} = await util.promisify(exec)(command);
   if (stderr) {
     throw new MissingRequirementError(toolName);
   }
@@ -24,14 +21,14 @@ type ExecuteCommandByPlatformInput = {
   [key in RunningPlatform]: string;
 };
 
-export function executeCommand(
+export async function executeCommand(
   cmdsByPlatform: ExecuteCommandByPlatformInput,
   toolName?: string,
-): PromiseWithChild<ExecuteCommandResult> {
+): Promise<ExecuteCommandResult> {
   const runningPlatform = getPlatform();
   const command = cmdsByPlatform[runningPlatform];
   try {
-    return asyncExec(command);
+    return await util.promisify(exec)(command);
   } catch (error: any) {
     throw new Error(`Error executing ${toolName || command}: ${error.message}.`);
   }
@@ -51,7 +48,7 @@ export function openUrl(url: string): Promise<ChildProcess> {
 
 export async function getVersion(toolName: string): Promise<string> {
   try {
-    const toolResponse = await asyncExec(`${toolName} --version`);
+    const toolResponse = await util.promisify(exec)(`${toolName} --version`);
 
     if (toolResponse.stderr) {
       throw new Error(toolResponse.stderr);
@@ -74,29 +71,27 @@ export async function getVersion(toolName: string): Promise<string> {
 
 export async function listDockerContainers(): Promise<string[]> {
   try {
-    const dockerResponse = await asyncExec("docker ps -a --format '{{.Names}}'");
+    const dockerResponse = await util.promisify(exec)("docker ps -a --format '{{.Names}}'");
     const dockerContainers = dockerResponse.stdout.split("\n");
     return dockerContainers;
   } catch (error) {
     throw new Error("Error listing Docker containers.");
   }
-  return [];
 }
 
 export async function listDockerImages(): Promise<string[]> {
   try {
-    const dockerResponse = await asyncExec("docker images --format '{{.Repository}}'");
+    const dockerResponse = await util.promisify(exec)("docker images --format '{{.Repository}}'");
     const dockerImages = dockerResponse.stdout.split("\n");
     return dockerImages;
   } catch (error) {
     throw new Error("Error listing Docker images.");
   }
-  return [];
 }
 
 export async function stopDockerContainer(containerName: string): Promise<void> {
   try {
-    await asyncExec(`docker stop ${containerName}`);
+    await util.promisify(exec)(`docker stop ${containerName}`);
   } catch (error) {
     throw new Error(`Error stopping Docker container ${containerName}.`);
   }
@@ -104,7 +99,7 @@ export async function stopDockerContainer(containerName: string): Promise<void>
 
 export async function removeDockerContainer(containerName: string) {
   try {
-    await asyncExec(`docker rm ${containerName}`);
+    await util.promisify(exec)(`docker rm ${containerName}`);
   } catch (error) {
     throw new Error(`Error removing container ${containerName}.`);
   }
@@ -112,7 +107,7 @@ export async function removeDockerContainer(containerName: string) {
 
 export async function removeDockerImage(imageName: string) {
   try {
-    await asyncExec(`docker rmi ${imageName}`);
+    await util.promisify(exec)(`docker rmi ${imageName}`);
   } catch (error) {
     throw new Error(`Error removing image ${imageName}.`);
   }

package/src/lib/services/simulator.ts

@@ -221,8 +221,8 @@ export class SimulatorService implements ISimulatorService {
       const response = await rpcClient.request({method: "ping", params: []});
 
       //Compatibility with current simulator version
-      if (response && (response.result.status === "OK" || response.result.data.status === "OK")) {
-        return {initialized: true};
+      if (response?.result?.status === "OK" || response?.result?.data?.status === "OK") {
+        return { initialized: true };
       }
       if (retries > 0) {
         await sleep(STARTING_TIMEOUT_WAIT_CYLCE);

package/tests/libs/system.test.ts

@@ -0,0 +1,223 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+import util from "node:util";
+import {
+  checkCommand,
+  executeCommand,
+  openUrl,
+  getVersion,
+  listDockerContainers,
+  listDockerImages,
+  stopDockerContainer,
+  removeDockerContainer,
+  removeDockerImage
+} from "../../src/lib/clients/system";
+import { MissingRequirementError } from "../../src/lib/errors/missingRequirement";
+import open from "open";
+
+vi.mock("open");
+vi.mock("util");
+
+describe("System Functions - Success Paths", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("openUrl opens URL successfully", async () => {
+    const openSpy = vi.mocked(open).mockResolvedValue({} as any);
+    const url = "https://example.com";
+    await openUrl(url);
+    expect(openSpy).toHaveBeenCalledWith(url);
+  });
+
+  test("getVersion retrieves tool version", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "git v1.2.3",
+      stderr: ""
+    }));
+    const version = await getVersion("git");
+    expect(version).toBe("1.2.3");
+  });
+
+  test("checkCommand verifies a command exists", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({ stdout: "", stderr: "" }));
+    const result = await checkCommand("node --version", "node");
+    expect(result).toBe(undefined);
+  });
+
+  test("executeCommand executes a command successfully", async () => {
+    const platformSpy = vi.spyOn(process, "platform", "get").mockReturnValue("linux");
+    vi.mocked(util.promisify).mockReturnValueOnce((param: string) => Promise.resolve({
+      stdout: param,
+      stderr: ""
+    }));
+    const result = await executeCommand({
+        linux: "echo linux",
+        win32: "echo win32",
+        darwin: "echo darwin",
+      },
+      "echo");
+    expect(result.stdout).toBe("echo linux");
+    platformSpy.mockRestore();
+  });
+
+  test("listDockerContainers retrieves a list of containers", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "container1\ncontainer2",
+      stderr: ""
+    }));
+    const containers = await listDockerContainers();
+    expect(containers).toEqual(["container1", "container2"]);
+  });
+
+  test("listDockerImages retrieves a list of images", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "image1\nimage2",
+      stderr: ""
+    }));
+    const images = await listDockerImages();
+    expect(images).toEqual(["image1", "image2"]);
+  });
+
+  test("stopDockerContainer stops a container", async () => {
+    const containerId = "container123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await stopDockerContainer(containerId);
+    expect(execMock).toHaveBeenCalledWith(`docker stop ${containerId}`);
+  });
+
+  test("removeDockerContainer removes a container", async () => {
+    const containerId = "container123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await removeDockerContainer(containerId);
+    expect(execMock).toHaveBeenCalledWith(`docker rm ${containerId}`);
+  });
+
+  test("removeDockerImage removes an image", async () => {
+    const imageId = "image123";
+    const execMock = vi.fn().mockResolvedValue({ stdout: "", stderr: "" });
+    vi.mocked(util.promisify).mockReturnValue(execMock);
+    await removeDockerImage(imageId);
+    expect(execMock).toHaveBeenCalledWith(`docker rmi ${imageId}`);
+  });
+});
+
+describe("System Functions - Error Paths", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("getVersion throws an error if the command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: "command not found"
+    }));
+    const toolName = "nonexistent";
+    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
+  });
+
+  test("getVersion returns '' if stdout is empty", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: ""
+    }));
+    const result = await getVersion('git');
+    expect(result).toBe("");
+  });
+
+  test("getVersion throw error if stdout undefined", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stderr: ""
+    }));
+    const toolName = "nonexistent";
+    await expect(getVersion(toolName)).rejects.toThrow(`Error getting ${toolName} version.`);
+  });
+
+  test("checkCommand returns false if the command does not exist", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.resolve({
+      stdout: "",
+      stderr: "command not found"
+    }));
+    const toolName = 'nonexistent';
+    await expect(checkCommand(`${toolName} --version`, toolName)).rejects.toThrow(new MissingRequirementError(toolName));
+  });
+
+  test("executeCommand throws an error if the command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution failed")));
+    await expect(executeCommand({
+        linux: "echo hello",
+        win32: "echo hello",
+        darwin: "echo hello",
+      },
+      "echo")).rejects.toThrow("Execution failed");
+  });
+
+  test("stopDockerContainer throws an error if stopping fails", async () => {
+    const containerId = "container123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(stopDockerContainer(containerId)).rejects.toThrow("Error stopping Docker container container123");
+  });
+
+  test("removeDockerContainer throws an error if removal fails", async () => {
+    const containerId = "container123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(removeDockerContainer(containerId)).rejects.toThrow("Error removing container container123.");
+  });
+
+  test("removeDockerImage throws an error if image removal fails", async () => {
+    const imageId = "image123";
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(removeDockerImage(imageId)).rejects.toThrow("Error removing image image123.");
+  });
+
+  test("throws error when command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(listDockerContainers()).rejects.toThrow("Error listing Docker containers.");
+  });
+
+  test("throws error when command fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("")));
+    await expect(listDockerImages()).rejects.toThrow("Error listing Docker images.");
+  });
+
+  test("throws error when command execution fails", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
+    await expect(executeCommand({
+      linux: "echo no toolname",
+      win32: "echo no toolname",
+      darwin: "echo no toolname",
+    })).rejects.toThrow(
+      "Error executing echo no toolname: Execution error."
+    );
+  });
+
+  test("throws error when command execution fails (toolname)", async () => {
+    vi.mocked(util.promisify).mockReturnValueOnce(() => Promise.reject(new Error("Execution error.")));
+    await expect(executeCommand({
+        linux: "echo linux",
+        win32: "echo win32",
+        darwin: "echo darwin",
+      },
+      "echo")).rejects.toThrow(
+      "Error executing echo: Execution error."
+    );
+  });
+
+  test("throws an error for unsupported platform in executeCommand", () => {
+    const unsupportedPlatform = "unsupportedOS";
+    const originalPlatform = process.platform;
+    Object.defineProperty(process, "platform", {
+      value: unsupportedPlatform,
+    });
+    const cmdsByPlatform = {
+      linux: "echo Linux",
+      darwin: "echo macOS",
+      win32: "echo Windows",
+    };
+    expect(executeCommand(cmdsByPlatform)).rejects.toThrow(
+      `Unsupported platform: ${unsupportedPlatform}.`
+    );
+    Object.defineProperty(process, "platform", { value: originalPlatform });
+  });
+});

package/tests/services/simulator.test.ts

@@ -0,0 +1,283 @@
+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,
+  stopDockerContainer,
+  removeDockerContainer, listDockerContainers,
+} from "../../src/lib/clients/system";
+import {
+  DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX,
+  VERSION_REQUIREMENTS,
+} from "../../src/lib/config/simulator";
+import {
+  STARTING_TIMEOUT_ATTEMPTS,
+  DEFAULT_RUN_SIMULATOR_COMMAND,
+  DEFAULT_RUN_DOCKER_COMMAND,
+  DEFAULT_PULL_OLLAMA_COMMAND
+} from "../../src/lib/config/simulator";
+import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
+import * as semver from "semver";
+
+
+vi.mock("fs");
+vi.mock("path");
+vi.mock("dotenv");
+vi.mock("semver", () => ({
+  satisfies: vi.fn(),
+}));
+vi.mock("../../src/lib/clients/system", () => ({
+  checkCommand: vi.fn(),
+  getVersion: vi.fn(),
+  executeCommand: vi.fn(),
+  openUrl: vi.fn(),
+  listDockerContainers: vi.fn(),
+  stopDockerContainer: vi.fn(),
+  removeDockerContainer: vi.fn(),
+}));
+
+vi.mock("../../src/lib/clients/jsonRpcClient", () => ({
+  rpcClient: {
+    request: vi.fn(),
+  },
+}));
+
+describe("SimulatorService - Basic Tests", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(path.join).mockImplementation((...args) => args.join("/"));
+  });
+
+  test("should return the correct simulator location path", () => {
+    const expectedPath = "/mock/home/genlayer-simulator";
+    simulatorService.setSimulatorLocation("/mock/home/genlayer-simulator");
+    const simulatorLocation = simulatorService.getSimulatorLocation();
+    expect(simulatorLocation).toBe(expectedPath);
+  });
+
+  test("should read the correct frontend URL from .env config", () => {
+    const mockEnvFilePath = "/mock/home/genlayer-simulator/.env";
+    const mockEnvContent = "FRONTEND_PORT=8080";
+    const mockEnvConfig = { FRONTEND_PORT: "8080" };
+    vi.mocked(fs.readFileSync).mockReturnValue(mockEnvContent);
+    vi.mocked(dotenv.parse).mockReturnValue(mockEnvConfig);
+    simulatorService.setSimulatorLocation("/mock/home/genlayer-simulator");
+    const frontendUrl = simulatorService.getFrontendUrl();
+    expect(frontendUrl).toBe("http://localhost:8080");
+    expect(fs.readFileSync).toHaveBeenCalledWith(mockEnvFilePath, "utf8");
+  });
+
+  test("should check version requirements and return missing versions", async () => {
+    vi.mocked(getVersion).mockResolvedValueOnce("12.0.0").mockResolvedValueOnce("18.0.0");
+    vi.mocked(semver.satisfies).mockImplementation((version, range) => {
+      if (range === VERSION_REQUIREMENTS.node) return version === "18.0.0";
+      return false;
+    });
+    const missingVersions = await simulatorService.checkVersionRequirements();
+    expect(missingVersions.node).toBe(VERSION_REQUIREMENTS.node);
+    expect(missingVersions.docker).toBe(VERSION_REQUIREMENTS.docker);
+  });
+
+  test("should handle error when checkVersion throws VersionRequiredError", async () => {
+    vi.mocked(getVersion).mockResolvedValueOnce("10.0.0");
+    vi.mocked(semver.satisfies).mockReturnValue(false);
+    await expect(simulatorService.checkVersion("14.0.0", "node")).rejects.toThrow();
+  });
+
+  test("should download simulator if not already installed", async () => {
+    const result = await simulatorService.downloadSimulator();
+    expect(result.wasInstalled).toBe(false);
+    expect(executeCommand).toHaveBeenCalled();
+  });
+
+  test("should skip download if simulator is already installed", async () => {
+    vi.mocked(executeCommand).mockRejectedValueOnce(new Error("Mocked command error"));
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    const result = await simulatorService.downloadSimulator();
+    expect(result.wasInstalled).toBe(true);
+    expect(executeCommand).toHaveBeenCalled();
+    expect(fs.existsSync).toHaveBeenCalled();
+  });
+
+  test("should return initialized true when simulator responds with OK", async () => {
+    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: [] });
+  });
+
+  test("should return initialized true when simulator responds with OK (different json structure)", async () => {
+    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: [] });
+  });
+
+  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" });
+  });
+
+  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 });
+  });
+
+  test("should execute the correct pull command based on simulator location", async () => {
+    const expectedCommand = DEFAULT_PULL_OLLAMA_COMMAND("/mock/home/genlayer-simulator");
+    vi.mocked(executeCommand).mockResolvedValueOnce({
+      stdout: "success",
+      stderr: "",
+    });
+    const result = await simulatorService.pullOllamaModel();
+    expect(result).toBe(true);
+    expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
+  });
+
+  test("should execute the correct run simulator command based on simulator location", async () => {
+    (executeCommand as Mock).mockResolvedValue({
+      stdout: "Simulator started",
+      stderr: "",
+    });
+    const result = await simulatorService.runSimulator();
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator");
+    expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
+    expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
+  });
+
+  test("should open the frontend URL and return true", async () => {
+    vi.spyOn(simulatorService, "getFrontendUrl").mockReturnValue("http://localhost:8080");
+    const result = await simulatorService.openFrontend();
+    expect(simulatorService.getFrontendUrl).toHaveBeenCalled();
+    expect(openUrl).toHaveBeenCalledWith("http://localhost:8080");
+    expect(result).toBe(true);
+  });
+
+  test("should call rpcClient.request with correct parameters and return the response", async () => {
+    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(result).toBe(mockResponse);
+  });
+
+  test("should throw an unexpected error when checking node version requirements", async () => {
+    const unexpectedError = new Error("Unexpected error (node)");
+    vi.spyOn(simulatorService, "checkVersion").mockRejectedValueOnce(unexpectedError);
+    await expect(simulatorService.checkVersionRequirements()).rejects.toThrow("Unexpected error (node)");
+  });
+
+  test("should throw an unexpected error when checking docker version requirements", async () => {
+    vi.spyOn(simulatorService, "checkVersion")
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error("Unexpected error (docker)"));
+    await expect(simulatorService.checkVersionRequirements()).rejects.toThrow("Unexpected error (docker)");
+  });
+
+  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 };
+    expect(requirementsInstalled.git).toBe(false);
+  });
+
+  test("should throw an unexpected error when checking docker installation requirement", async () => {
+    vi.mocked(checkCommand)
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error("Unexpected docker error"));
+    await expect(simulatorService.checkInstallRequirements()).rejects.toThrow("Unexpected docker error");
+    const requirementsInstalled = { git: false, docker: false };
+    expect(requirementsInstalled.docker).toBe(false);
+  });
+
+  test("should stop and remove Docker containers with the specified prefix", async () => {
+    const mockContainers = [
+      DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "1",
+      DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "2"
+    ];
+    vi.mocked(listDockerContainers).mockResolvedValue(mockContainers);
+    vi.mocked(stopDockerContainer).mockResolvedValue(undefined);
+    vi.mocked(removeDockerContainer).mockResolvedValue(undefined);
+    const result = await simulatorService.resetDockerContainers();
+    expect(result).toBe(true);
+    expect(stopDockerContainer).toHaveBeenCalledWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "1");
+    expect(stopDockerContainer).toHaveBeenCalledWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "2");
+    expect(removeDockerContainer).toHaveBeenCalledWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "1");
+    expect(removeDockerContainer).toHaveBeenCalledWith(DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX + "2");
+  });
+
+  test("should retry when response is not 'OK' and reach sleep path", async () => {
+    vi.mocked(rpcClient.request).mockResolvedValue({ result: { status: "NOT_OK" } });
+    const result = await simulatorService.waitForSimulatorToBeReady(1);
+    expect(result).toEqual({ initialized: false, errorCode: "TIMEOUT" });
+  });
+
+  test("should retry on fetch error and reach sleep path", async () => {
+    const fetchError = new Error("Fetch Error");
+    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 });
+  });
+
+  test("should throw an error if executeCommand fails and simulator location does not exist", async () => {
+    const mockError = new Error("git clone failed");
+    vi.mocked(executeCommand).mockRejectedValueOnce(mockError);
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    await expect(simulatorService.downloadSimulator()).rejects.toThrow("git clone failed");
+    expect(executeCommand).toHaveBeenCalled();
+    expect(fs.existsSync).toHaveBeenCalledWith("/mock/home/genlayer-simulator");
+  });
+
+  test("should call executeCommand if docker ps command fails", async () => {
+    vi.mocked(checkCommand)
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce(undefined)
+      .mockRejectedValueOnce(new Error("docker ps failed"));
+    vi.mocked(executeCommand).mockResolvedValueOnce({
+      stdout: '',
+      stderr: ''
+    });
+    const result = await simulatorService.checkInstallRequirements();
+    expect(executeCommand).toHaveBeenCalledWith(DEFAULT_RUN_DOCKER_COMMAND);
+    expect(result.docker).toBe(true);
+    expect(result.git).toBe(true);
+  });
+
+  test("should update envConfig with newConfig values", () => {
+    const envFilePath = path.join("/mock/home/genlayer-simulator", ".env");
+    const originalEnvContent = "KEY1=value1\nKEY2=value2";
+    const envConfig = { KEY1: "value1", KEY2: "value2" };
+    const newConfig = { KEY2: "new_value2", KEY3: "value3" };
+    vi.mocked(fs.readFileSync)
+      .mockReturnValueOnce(originalEnvContent)
+      .mockReturnValueOnce(originalEnvContent);
+    vi.mocked(dotenv.parse).mockReturnValue(envConfig);
+    const writeFileSyncSpy = vi.spyOn(fs, "writeFileSync");
+    simulatorService["addConfigToEnvFile"](newConfig);
+    expect(envConfig).toEqual({
+      KEY1: "value1",
+      KEY2: "new_value2",
+      KEY3: "value3",
+    });
+    expect(writeFileSyncSpy).toHaveBeenCalledWith(`${envFilePath}.bak`, originalEnvContent);
+    expect(writeFileSyncSpy).toHaveBeenCalledWith(
+      envFilePath,
+      "KEY1=value1\nKEY2=new_value2\nKEY3=value3"
+    );
+  });
+
+  test("should return providers without errors", () => {
+    expect(simulatorService.getAiProvidersOptions(true)).toEqual(expect.any(Array));
+    expect(simulatorService.getAiProvidersOptions(false)).toEqual(expect.any(Array));
+  });
+
+});