genlayer 0.5.0 → 0.5.1-beta.0

package/tests/actions/init.test.ts

@@ -5,6 +5,13 @@ import { initAction } from "../../src/commands/general/init";
 import { tmpdir } from "os";
 import {mkdtempSync} from "fs";
 import {join} from "path";
+import fs from "fs";
+import * as dotenv from "dotenv";
+
+
+vi.mock("fs");
+vi.mock("dotenv");
+
 
 const tempDir = mkdtempSync(join(tmpdir(), "test-initAction-"));
 const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false };
@@ -18,9 +25,7 @@ describe("init action", () => {
   let simServCheckVersionRequirements: ReturnType<any>;
   let simServResetDockerContainers: ReturnType<any>;
   let simServResetDockerImages: ReturnType<any>;
-  let simServDownloadSimulator: ReturnType<any>;
   let simServgetAiProvidersOptions: ReturnType<any>;
-  let simServConfigSimulator: ReturnType<any>;
   let simServRunSimulator: ReturnType<any>;
   let simServWaitForSimulator: ReturnType<any>;
   let simServPullOllamaModel: ReturnType<any>;
@@ -28,6 +33,7 @@ describe("init action", () => {
   let simServCreateRandomValidators: ReturnType<any>;
   let simServOpenFrontend: ReturnType<any>;
   let simGetSimulatorUrl: ReturnType<any>;
+  let simAddConfigToEnvFile: ReturnType<any>;
 
   beforeEach(() => {
     vi.clearAllMocks();
@@ -40,8 +46,6 @@ describe("init action", () => {
     simServCheckVersionRequirements = vi.spyOn(simulatorService, "checkVersionRequirements");
     simServResetDockerContainers = vi.spyOn(simulatorService, "resetDockerContainers");
     simServResetDockerImages = vi.spyOn(simulatorService, "resetDockerImages");
-    simServDownloadSimulator = vi.spyOn(simulatorService, "downloadSimulator");
-    simServConfigSimulator = vi.spyOn(simulatorService, "configSimulator");
     simServgetAiProvidersOptions = vi.spyOn(simulatorService, "getAiProvidersOptions");
     simServRunSimulator = vi.spyOn(simulatorService, "runSimulator");
     simServWaitForSimulator = vi.spyOn(simulatorService, "waitForSimulatorToBeReady");
@@ -50,6 +54,7 @@ describe("init action", () => {
     simServCreateRandomValidators = vi.spyOn(simulatorService, "createRandomValidators");
     simServOpenFrontend = vi.spyOn(simulatorService, "openFrontend");
     simGetSimulatorUrl = vi.spyOn(simulatorService, "getFrontendUrl")
+    simAddConfigToEnvFile = vi.spyOn(simulatorService, "addConfigToEnvFile")
 
     simServCheckVersionRequirements.mockResolvedValue({
       node: '',
@@ -59,22 +64,17 @@ describe("init action", () => {
       git: true,
       docker: true,
     })
+    simAddConfigToEnvFile.mockResolvedValue(true);
+    const mockEnvContent = "FRONTEND_PORT=8080";
+    const mockEnvConfig = { FRONTEND_PORT: "8080" };
+    vi.mocked(fs.readFileSync).mockReturnValue(mockEnvContent);
+    vi.mocked(dotenv.parse).mockReturnValue(mockEnvConfig);
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  test("if both requirements are missing, then the execution fails", async () => {
-    simServCheckInstallRequirements.mockResolvedValue({ git: false, docker: false });
-
-    await initAction(defaultActionOptions, simulatorService);
-
-    expect(error).toHaveBeenCalledWith(
-      "Git and Docker are not installed. Please install them and try again.\n"
-    );
-  });
-
   test("if only docker is missing, then the execution fails", async () => {
     simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: false });
 
@@ -83,14 +83,6 @@ describe("init action", () => {
     expect(error).toHaveBeenCalledWith("Docker is not installed. Please install Docker and try again.\n");
   });
 
-  test("if only git is missing, then the execution fails", async () => {
-    simServCheckInstallRequirements.mockResolvedValue({ git: false, docker: true });
-
-    await initAction(defaultActionOptions, simulatorService);
-
-    expect(error).toHaveBeenCalledWith("Git is not installed. Please install Git and try again.\n");
-  });
-
   test("if check install requirements fail, then the execution aborts", async () => {
     simServCheckInstallRequirements.mockRejectedValue(new Error("Error"));
 
@@ -169,7 +161,6 @@ describe("init action", () => {
       { name: "OpenAI", value: "openai" },
       { name: "Heurist", value: "heuristai" },
     ]);
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServPullOllamaModel.mockResolvedValue(true);
@@ -200,7 +191,6 @@ describe("init action", () => {
       { name: "OpenAI", value: "openai" },
       { name: "Heurist", value: "heuristai" },
     ]);
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServPullOllamaModel.mockResolvedValue(true);
@@ -230,7 +220,6 @@ describe("init action", () => {
       { name: "OpenAI", value: "openai" },
       { name: "Heurist", value: "heuristai" },
     ]);
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServPullOllamaModel.mockResolvedValue(true);
@@ -248,18 +237,6 @@ describe("init action", () => {
     expect(error).toHaveBeenCalledWith('Unable to initialize the validators.');
   });
 
-
-  test("if configSimulator fails, then the execution aborts", async () => {
-    inquirerPrompt.mockResolvedValue({ confirmReset: true, confirmDownload: true, selectedLlmProviders: [] });
-    simServConfigSimulator.mockRejectedValue(new Error("Error"));
-    simServResetDockerContainers.mockResolvedValue(true);
-    simServResetDockerImages.mockResolvedValue(true);
-
-    await initAction(defaultActionOptions, simulatorService);
-
-    expect(error).toHaveBeenCalledWith(new Error("Error"));
-  });
-
   test("if runSimulator fails, then the execution aborts", async () => {
     inquirerPrompt.mockResolvedValue({ confirmReset: true, confirmDownload: true, selectedLlmProviders: [] });
     simServRunSimulator.mockRejectedValue(new Error("Error"));
@@ -285,7 +262,7 @@ describe("init action", () => {
       { name: "Heurist", value: "heuristai" },
       { name: "Ollama", value: "ollama" },
     ]);
-    simServConfigSimulator.mockResolvedValue(true);
+
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServPullOllamaModel.mockResolvedValue(true);
@@ -308,20 +285,6 @@ describe("init action", () => {
     expect(error).toHaveBeenCalledWith(errorMsg);
   });
 
-  test("logs 'Aborted!' if confirmDownload is false", async () => {
-    inquirerPrompt
-      .mockResolvedValueOnce({ confirmReset: true })
-      .mockResolvedValueOnce({ confirmDownload: false });
-
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
-    simServResetDockerContainers.mockResolvedValue(true);
-    simServResetDockerImages.mockResolvedValue(true);
-
-    await initAction(defaultActionOptions, simulatorService);
-
-    expect(log).toHaveBeenCalledWith("Aborted!");
-  });
-
   test("logs error if resetDockerContainers throws", async () => {
     inquirerPrompt.mockResolvedValue({ confirmReset: true });
     simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
@@ -334,9 +297,11 @@ describe("init action", () => {
   });
 
   test("prompts for LLM providers and validates that at least one is selected", async () => {
+    const mockEnvContent = "FRONTEND_PORT=8080";
+    vi.mocked(fs.readFileSync).mockReturnValue(mockEnvContent);
+
     inquirerPrompt
       .mockResolvedValueOnce({ confirmReset: true })
-      .mockResolvedValueOnce({ confirmDownload: true })
       .mockImplementation((questions: any) => {
         if (questions[0].type === "checkbox") {
           const validateFunction = questions[0].validate;
@@ -353,11 +318,9 @@ describe("init action", () => {
         }
       });
 
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
+    simServCheckInstallRequirements.mockResolvedValue({ docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServDeleteAllValidators.mockResolvedValue(true);
@@ -367,31 +330,16 @@ describe("init action", () => {
     await initAction(defaultActionOptions, simulatorService);
   });
 
-  test("logs error if downloadSimulator throws", async () => {
-    inquirerPrompt.mockResolvedValue({ confirmReset: true, confirmDownload: true });
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
-    simServResetDockerContainers.mockResolvedValue(true);
-    simServResetDockerImages.mockResolvedValue(true);
-    const errorMsg = new Error("downloadSimulator error");
-    simServDownloadSimulator.mockRejectedValueOnce(errorMsg);
-
-    await initAction(defaultActionOptions, simulatorService);
-
-    expect(error).toHaveBeenCalledWith(errorMsg);
-  });
 
   test("logs error message if simulator fails to initialize with ERROR code", async () => {
     inquirerPrompt
       .mockResolvedValueOnce({ confirmReset: true })
-      .mockResolvedValueOnce({ confirmDownload: true })
       .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
       .mockResolvedValueOnce({ openai: "API_KEY1" });
 
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
+    simServCheckInstallRequirements.mockResolvedValue({ docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
 
     simServWaitForSimulator.mockResolvedValue({
@@ -416,8 +364,6 @@ describe("init action", () => {
     simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     const errorMsg = new Error("runSimulator error");
     simServRunSimulator.mockRejectedValueOnce(errorMsg);
 
@@ -436,8 +382,6 @@ describe("init action", () => {
     simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({
       initialized: false,
@@ -455,15 +399,12 @@ describe("init action", () => {
   test("catches and logs error if waitForSimulatorToBeReady throws an exception", async () => {
     inquirerPrompt
       .mockResolvedValueOnce({ confirmReset: true })
-      .mockResolvedValueOnce({ confirmDownload: true })
       .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
       .mockResolvedValueOnce({ openai: "API_KEY1" });
 
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
+    simServCheckInstallRequirements.mockResolvedValue({ docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
 
     const errorMsg = new Error("Unexpected simulator error");
@@ -475,17 +416,17 @@ describe("init action", () => {
   });
 
   test("catches and logs error if openFrontend throws an exception", async () => {
+    const mockEnvContent = "FRONTEND_PORT=8080";
+    vi.mocked(fs.readFileSync).mockReturnValue(mockEnvContent);
+
     inquirerPrompt
       .mockResolvedValueOnce({ confirmReset: true })
-      .mockResolvedValueOnce({ confirmDownload: true })
       .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
       .mockResolvedValueOnce({ openai: "API_KEY1" });
 
-    simServCheckInstallRequirements.mockResolvedValue({ git: true, docker: true });
+    simServCheckInstallRequirements.mockResolvedValue({ docker: true });
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
-    simServDownloadSimulator.mockResolvedValue({ wasInstalled: false });
-    simServConfigSimulator.mockResolvedValue(true);
     simServRunSimulator.mockResolvedValue(true);
     simServWaitForSimulator.mockResolvedValue({ initialized: true });
     simServDeleteAllValidators.mockResolvedValue(true);

package/tests/actions/start.test.ts

@@ -12,8 +12,6 @@ describe("startAction - Additional Tests", () => {
   const defaultOptions: StartActionOptions = {
     resetValidators: false,
     numValidators: 5,
-    branch: "main",
-    location: '',
     headless: false,
     resetDb: false
   };
@@ -49,13 +47,10 @@ describe("startAction - Additional Tests", () => {
   test("runs successfully with default options and keeps existing validators", async () => {
     await startAction(defaultOptions, simulatorService);
 
-    expect(simulatorService.updateSimulator).toHaveBeenCalledWith("main");
     expect(simulatorService.runSimulator).toHaveBeenCalled();
     expect(simulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
 
     expect(logSpy).toHaveBeenCalledWith("Starting GenLayer simulator keeping the existing validators");
-    expect(logSpy).toHaveBeenCalledWith("Updating GenLayer Simulator...");
-    expect(logSpy).toHaveBeenCalledWith("Running the GenLayer Simulator...");
     expect(logSpy).toHaveBeenCalledWith("Simulator is running!");
     expect(logSpy).toHaveBeenCalledWith("GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.");
 
@@ -65,26 +60,15 @@ describe("startAction - Additional Tests", () => {
   test("runs successfully with custom options and keeps existing validators", async () => {
     await startAction({...defaultOptions, headless: true, resetDb: true}, simulatorService);
 
-    expect(simulatorService.updateSimulator).toHaveBeenCalledWith("main");
     expect(simulatorService.runSimulator).toHaveBeenCalled();
     expect(simulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
 
     expect(logSpy).toHaveBeenCalledWith("Starting GenLayer simulator keeping the existing validators");
-    expect(logSpy).toHaveBeenCalledWith("Updating GenLayer Simulator...");
-    expect(logSpy).toHaveBeenCalledWith("Running the GenLayer Simulator...");
+
     expect(logSpy).toHaveBeenCalledWith("Simulator is running!");
     expect(logSpy).toHaveBeenCalledWith("GenLayer simulator initialized successfully! ");
   });
 
-  test("logs error and stops if updateSimulator fails", async () => {
-    const errorMsg = new Error("updateSimulator error");
-    (simulatorService.updateSimulator as Mock).mockRejectedValueOnce(errorMsg);
-
-    await startAction(defaultOptions, simulatorService);
-
-    expect(errorSpy).toHaveBeenCalledWith(errorMsg);
-    expect(simulatorService.runSimulator).not.toHaveBeenCalled();
-  });
 
   test("logs error and stops if runSimulator fails", async () => {
     const errorMsg = new Error("runSimulator error");

package/tests/commands/init.test.ts

@@ -7,8 +7,6 @@ import simulatorService from  '../../src/lib/services/simulator'
 const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 const defaultOptions = {
   numValidators: "5",
-  branch: "main",
-  location: process.cwd(),
   headless: false,
   resetDb: false
 }
@@ -52,21 +50,6 @@ describe("init command", () => {
     expect(numValidatorsOption?.defaultValue).toBe("5");
   });
 
-  test("option --branch is accepted", async () => {
-    expect(() => program.parse(["node", "test", "init", "--branch", "example"])).not.toThrow();
-  });
-
-  test("option --branch default value is main", async () => {
-    const branchOption = getCommandOption(initCommand, "--branch");
-    expect(branchOption?.defaultValue).toBe("main");
-  });
-
-  test("option --location default value is user's current directory", async () => {
-    // Given // When
-    const locationOption = getCommandOption(initCommand, "--location");
-    expect(locationOption?.defaultValue).toBe(process.cwd());
-  });
-
 
   test("random option is not accepted", async () => {
     initCommand?.exitOverride();

package/tests/commands/up.test.ts

@@ -10,8 +10,6 @@ const action = vi.fn();
 const defaultOptions = {
   resetValidators: false,
   numValidators: "5",
-  branch: "main",
-  location: process.cwd(),
   headless: false ,
   resetDb: false
 }
@@ -58,14 +56,6 @@ describe("up command", () => {
     expect(numValidatorsOption?.defaultValue).toBe("5");
   });
 
-  test("option --branch is accepted", async () => {
-    expect(() => program.parse(["node", "test", "up", "--branch", "development"])).not.toThrow();
-  });
-
-  test("option --branch default value is main", async () => {
-    const branchOption = getCommandOption(upCommand, "--branch");
-    expect(branchOption?.defaultValue).toBe("main");
-  });
 
   test("unrecognized option is not accepted", async () => {
     upCommand?.exitOverride();
@@ -91,15 +81,13 @@ describe("up command", () => {
       "--reset-validators",
       "--numValidators",
       "10",
-      "--branch",
-      "development",
       "--headless",
       "true",
       "--reset-db",
       "true"
     ]);
     expect(action).toHaveBeenCalledTimes(1);
-    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true, branch: 'development', numValidators: '10', resetValidators: true, resetDb: true});
+    expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true, numValidators: '10', resetValidators: true, resetDb: true});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
 });

package/tests/services/simulator.test.ts

@@ -12,8 +12,6 @@ import {
 import {
   DOCKER_IMAGES_AND_CONTAINERS_NAME_PREFIX,
   VERSION_REQUIREMENTS,
-} from "../../src/lib/config/simulator";
-import {
   STARTING_TIMEOUT_ATTEMPTS,
   DEFAULT_RUN_SIMULATOR_COMMAND,
 } from "../../src/lib/config/simulator";
@@ -59,23 +57,14 @@ describe("SimulatorService - Basic Tests", () => {
     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 () => {
@@ -95,20 +84,6 @@ describe("SimulatorService - Basic Tests", () => {
     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 (result.status = OK)", async () => {
     vi.mocked(rpcClient.request).mockResolvedValueOnce({ result: {status: 'OK'} });
@@ -150,7 +125,7 @@ describe("SimulatorService - Basic Tests", () => {
       stderr: "",
     });
     const result = await simulatorService.runSimulator();
-    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator", '');
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorService.location, '');
     expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
     expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
   });
@@ -163,11 +138,57 @@ describe("SimulatorService - Basic Tests", () => {
     simulatorService.setComposeOptions(true)
     const commandOption = simulatorService.getComposeOptions();
     const result = await simulatorService.runSimulator();
-    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND("/mock/home/genlayer-simulator", commandOption);
+    const expectedCommand = DEFAULT_RUN_SIMULATOR_COMMAND(simulatorService.location, commandOption);
     expect(executeCommand).toHaveBeenCalledWith(expectedCommand);
     expect(result).toEqual({ stdout: "Simulator started", stderr: "" });
   });
 
+  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" };
+
+    vi.mocked(fs.readFileSync).mockImplementation((filePath: any) => {
+      if (filePath === envFilePath) return originalEnvContent;
+      return "";
+    });
+
+    vi.mocked(dotenv.parse).mockReturnValue(parsedEnvConfig);
+    const writeFileSyncMock = vi.mocked(fs.writeFileSync);
+
+    simulatorService.addConfigToEnvFile(newConfig);
+
+    const expectedUpdatedContent = `KEY1=value1\nKEY2=newValue2\nKEY3=value3`;
+    expect(writeFileSyncMock).toHaveBeenCalledWith(envFilePath, expectedUpdatedContent);
+  });
+
+  test("should handle empty .env file and add new config", () => {
+    const envFilePath = `/.env`;
+    const newConfig = { NEW_KEY: "newValue" };
+
+    vi.mocked(fs.readFileSync).mockReturnValue("");
+    vi.mocked(dotenv.parse).mockReturnValue({});
+    const writeFileSyncMock = vi.mocked(fs.writeFileSync);
+
+    simulatorService.addConfigToEnvFile(newConfig);
+
+    expect(writeFileSyncMock).toHaveBeenCalledWith(`${envFilePath}.bak`, "");
+    const expectedUpdatedContent = `NEW_KEY=newValue`;
+    expect(writeFileSyncMock).toHaveBeenCalledWith(envFilePath, expectedUpdatedContent);
+  });
+
+  test("should throw error when .env file does not exist", () => {
+    vi.mocked(fs.readFileSync).mockImplementation(() => {
+      throw new Error("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();
@@ -242,47 +263,14 @@ describe("SimulatorService - Basic Tests", () => {
     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)
 
-
     const result = await simulatorService.checkInstallRequirements();
     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));
@@ -314,8 +302,60 @@ describe("SimulatorService - Docker Tests", () => {
     mockPing = vi.mocked(Docker.prototype.ping);
   });
 
-  test("should pull the Ollama model", async () => {
-    mockGetContainer.mockReturnValueOnce({exec: mockExec} as unknown as Docker.Container);
+  test("should handle errors during the execution of pullOllamaModel gracefully", async () => {
+    const mockExec = vi.fn();
+    const mockStart = vi.fn();
+
+    mockExec.mockResolvedValue({
+      start: mockStart,
+    });
+
+    const mockStream = {
+      on: vi.fn((event, callback) => {
+        if (event === "data") callback("Mock data chunk");
+        if (event === "error") callback(new Error("Mock error during stream"));
+      }),
+    };
+
+    mockStart.mockResolvedValue(mockStream);
+
+    mockGetContainer.mockReturnValueOnce({
+      exec: mockExec,
+    } as unknown as Docker.Container);
+
+    const result = await simulatorService.pullOllamaModel();
+
+    expect(result).toBe(false);
+    expect(mockGetContainer).toHaveBeenCalledWith("ollama");
+    expect(mockExec).toHaveBeenCalledWith({
+      Cmd: ["ollama", "pull", "llama3"],
+      AttachStdout: true,
+      AttachStderr: true,
+    });
+    expect(mockStart).toHaveBeenCalledWith({ Detach: false, Tty: false });
+    expect(mockStream.on).toHaveBeenCalledWith("error", expect.any(Function));
+  });
+
+  test("should successfully execute pullOllamaModel and return true", async () => {
+    const mockExec = vi.fn();
+    const mockStart = vi.fn();
+
+    mockExec.mockResolvedValue({
+      start: mockStart,
+    });
+
+    const mockStream = {
+      on: vi.fn((event, callback) => {
+        if (event === "data") callback("Mock data chunk");
+        if (event === "end") callback();
+      }),
+    };
+
+    mockStart.mockResolvedValue(mockStream);
+
+    mockGetContainer.mockReturnValueOnce({
+      exec: mockExec,
+    } as unknown as Docker.Container);
 
     const result = await simulatorService.pullOllamaModel();
 
@@ -323,9 +363,15 @@ describe("SimulatorService - Docker Tests", () => {
     expect(mockGetContainer).toHaveBeenCalledWith("ollama");
     expect(mockExec).toHaveBeenCalledWith({
       Cmd: ["ollama", "pull", "llama3"],
+      AttachStdout: true,
+      AttachStderr: true,
     });
+    expect(mockStart).toHaveBeenCalledWith({ Detach: false, Tty: false });
+    expect(mockStream.on).toHaveBeenCalledWith("data", expect.any(Function));
+    expect(mockStream.on).toHaveBeenCalledWith("end", expect.any(Function));
   });
 
+
   test("should stop and remove Docker containers with the specified prefix", async () => {
     const mockContainers = [
       {
@@ -411,12 +457,12 @@ describe("SimulatorService - Docker Tests", () => {
     expect(executeCommand).toHaveBeenCalledTimes(1);
   });
 
-  test("should throw an unexpected error when checking docker installation requirement", async () => {
+  test("should call execute command again to start docker service", async () => {
     vi.mocked(checkCommand)
       .mockResolvedValueOnce(undefined)
       .mockRejectedValue(undefined);
-    mockPing.mockRejectedValueOnce("Unexpected docker error");
-    await expect(simulatorService.checkInstallRequirements()).rejects.toThrow("Unexpected docker error");
+    mockPing.mockRejectedValueOnce("");
+    await expect(simulatorService.checkInstallRequirements()).resolves.toStrictEqual({ docker: true });
   });
 
   test("should warn the user when an update is available", async () => {

package/vitest.config.ts

@@ -5,7 +5,7 @@ export default defineConfig({
     globals: true,
     environment: 'jsdom',
     coverage: {
-      exclude: [...configDefaults.exclude, '*.js', 'tests/**/*.ts', 'src/types'],
+      exclude: [...configDefaults.exclude, '*.js', 'tests/**/*.ts', 'src/types', 'scripts'],
     }
   }
 });