genlayer 0.18.1 → 0.18.2-beta.0

package/tests/actions/init.test.ts

@@ -1,8 +1,8 @@
-import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
 import inquirer from "inquirer";
-import { InitAction, InitActionOptions } from "../../src/commands/general/init";
-import { SimulatorService } from "../../src/lib/services/simulator";
-import { OllamaAction } from "../../src/commands/update/ollama";
+import {InitAction, InitActionOptions} from "../../src/commands/general/init";
+import {SimulatorService} from "../../src/lib/services/simulator";
+import {OllamaAction} from "../../src/commands/update/ollama";
 
 describe("InitAction", () => {
   let initAction: InitAction;
@@ -22,7 +22,7 @@ describe("InitAction", () => {
   let getFrontendUrlSpy: ReturnType<typeof vi.spyOn>;
   let normalizeLocalnetVersionSpy: ReturnType<typeof vi.spyOn>;
 
-  const defaultConfig = { defaultOllamaModel: "llama3" };
+  const defaultConfig = {defaultOllamaModel: "llama3"};
 
   const defaultOptions: InitActionOptions = {
     numValidators: 5,
@@ -44,19 +44,39 @@ describe("InitAction", () => {
     vi.spyOn(initAction as any, "logError").mockImplementation(() => {});
     vi.spyOn(initAction, "getConfig").mockReturnValue(defaultConfig);
     checkCliVersionSpy = vi.spyOn(SimulatorService.prototype, "checkCliVersion").mockResolvedValue(undefined);
-    checkInstallRequirementsSpy = vi.spyOn(SimulatorService.prototype, "checkInstallRequirements").mockResolvedValue({ git: true, docker: true });
-    checkVersionRequirementsSpy = vi.spyOn(SimulatorService.prototype, "checkVersionRequirements").mockResolvedValue({ node: "", docker: "" });
-    resetDockerContainersSpy = vi.spyOn(SimulatorService.prototype, "resetDockerContainers").mockResolvedValue(undefined);
-    resetDockerImagesSpy = vi.spyOn(SimulatorService.prototype, "resetDockerImages").mockResolvedValue(undefined);
+    checkInstallRequirementsSpy = vi
+      .spyOn(SimulatorService.prototype, "checkInstallRequirements")
+      .mockResolvedValue({git: true, docker: true});
+    checkVersionRequirementsSpy = vi
+      .spyOn(SimulatorService.prototype, "checkVersionRequirements")
+      .mockResolvedValue({node: "", docker: ""});
+    resetDockerContainersSpy = vi
+      .spyOn(SimulatorService.prototype, "resetDockerContainers")
+      .mockResolvedValue(undefined);
+    resetDockerImagesSpy = vi
+      .spyOn(SimulatorService.prototype, "resetDockerImages")
+      .mockResolvedValue(undefined);
     addConfigToEnvFileSpy = vi.spyOn(SimulatorService.prototype, "addConfigToEnvFile").mockResolvedValue();
-    runSimulatorSpy = vi.spyOn(SimulatorService.prototype, "runSimulator").mockResolvedValue(undefined as any);
-    waitForSimulatorSpy = vi.spyOn(SimulatorService.prototype, "waitForSimulatorToBeReady").mockResolvedValue({ initialized: true }) as any;
-    deleteAllValidatorsSpy = vi.spyOn(SimulatorService.prototype, "deleteAllValidators").mockResolvedValue(undefined);
-    createRandomValidatorsSpy = vi.spyOn(SimulatorService.prototype, "createRandomValidators").mockResolvedValue(undefined) as any;
+    runSimulatorSpy = vi
+      .spyOn(SimulatorService.prototype, "runSimulator")
+      .mockResolvedValue(undefined as any);
+    waitForSimulatorSpy = vi
+      .spyOn(SimulatorService.prototype, "waitForSimulatorToBeReady")
+      .mockResolvedValue({initialized: true}) as any;
+    deleteAllValidatorsSpy = vi
+      .spyOn(SimulatorService.prototype, "deleteAllValidators")
+      .mockResolvedValue(undefined);
+    createRandomValidatorsSpy = vi
+      .spyOn(SimulatorService.prototype, "createRandomValidators")
+      .mockResolvedValue(undefined) as any;
     cleanDatabaseSpy = vi.spyOn(SimulatorService.prototype, "cleanDatabase").mockResolvedValue(true);
     openFrontendSpy = vi.spyOn(SimulatorService.prototype, "openFrontend").mockResolvedValue(true);
-    getFrontendUrlSpy = vi.spyOn(SimulatorService.prototype, "getFrontendUrl").mockReturnValue("http://localhost:8080");
-    normalizeLocalnetVersionSpy = vi.spyOn(SimulatorService.prototype, "normalizeLocalnetVersion").mockImplementation((v: string) => v) as any;
+    getFrontendUrlSpy = vi
+      .spyOn(SimulatorService.prototype, "getFrontendUrl")
+      .mockReturnValue("http://localhost:8080");
+    normalizeLocalnetVersionSpy = vi
+      .spyOn(SimulatorService.prototype, "normalizeLocalnetVersion")
+      .mockImplementation((v: string) => v) as any;
     vi.spyOn(SimulatorService.prototype, "isLocalnetRunning").mockResolvedValue(false);
   });
 
@@ -67,64 +87,69 @@ describe("InitAction", () => {
   describe("Successful Execution", () => {
     test("should show combined confirmation message when localnet is running", async () => {
       vi.spyOn(SimulatorService.prototype, "isLocalnetRunning").mockResolvedValue(true);
-      
+
       const confirmPromptSpy = vi.spyOn(initAction as any, "confirmPrompt").mockResolvedValue(undefined);
-      
+
       inquirerPromptSpy
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
-        
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
+
       await initAction.execute(defaultOptions);
-      
+
       expect(confirmPromptSpy).toHaveBeenCalledWith(
-        "GenLayer Localnet is already running and this command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?"
+        "GenLayer Localnet is already running and this command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
       );
     });
-    
+
     test("should show standard confirmation message when localnet is not running", async () => {
       vi.spyOn(SimulatorService.prototype, "isLocalnetRunning").mockResolvedValue(false);
-      
+
       const confirmPromptSpy = vi.spyOn(initAction as any, "confirmPrompt").mockResolvedValue(undefined);
-      
+
       inquirerPromptSpy
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
-        
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
+
       await initAction.execute(defaultOptions);
-      
+
       expect(confirmPromptSpy).toHaveBeenCalledWith(
-        "This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?"
+        "This command is going to reset GenLayer docker images and containers, providers API Keys, and GenLayer database (accounts, transactions, validators and logs). Contract code (gpy files) will be kept. Do you want to continue?",
       );
     });
-    
+
     test("executes the full flow in non-headless mode", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai", "heuristai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" })
-        .mockResolvedValueOnce({ heuristai: "API_KEY_HEURIST" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai", "heuristai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"})
+        .mockResolvedValueOnce({heuristai: "API_KEY_HEURIST"});
       await initAction.execute(defaultOptions);
       expect(checkCliVersionSpy).toHaveBeenCalled();
       expect(checkInstallRequirementsSpy).toHaveBeenCalled();
       expect(checkVersionRequirementsSpy).toHaveBeenCalled();
       expect(resetDockerContainersSpy).toHaveBeenCalled();
       expect(resetDockerImagesSpy).toHaveBeenCalled();
-      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({ OPENAIKEY: "API_KEY_OPENAI", HEURISTAIAPIKEY: "API_KEY_HEURIST" });
-      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({ LOCALNETVERSION: "v1.0.0" });
+      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({
+        OPENAIKEY: "API_KEY_OPENAI",
+        HEURISTAIAPIKEY: "API_KEY_HEURIST",
+      });
+      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({LOCALNETVERSION: "v1.0.0"});
       expect(runSimulatorSpy).toHaveBeenCalled();
       expect(waitForSimulatorSpy).toHaveBeenCalled();
       expect(deleteAllValidatorsSpy).toHaveBeenCalled();
       expect(createRandomValidatorsSpy).toHaveBeenCalledWith(5, ["openai", "heuristai"]);
       expect(getFrontendUrlSpy).toHaveBeenCalled();
       expect(openFrontendSpy).toHaveBeenCalled();
-      expect((initAction as any).succeedSpinner).toHaveBeenCalledWith("GenLayer Localnet initialized successfully! Go to http://localhost:8080 in your browser to access it.");
+      expect((initAction as any).succeedSpinner).toHaveBeenCalledWith(
+        "GenLayer Localnet initialized successfully! Go to http://localhost:8080 in your browser to access it.",
+      );
     });
 
     test("executes correctly in headless mode with DB reset and 'ollama' selected", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai", "ollama"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai", "ollama"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       const ollamaUpdateSpy = vi.spyOn(OllamaAction.prototype, "updateModel").mockResolvedValue(undefined);
       const headlessOptions: InitActionOptions = {
         numValidators: 5,
@@ -136,7 +161,9 @@ describe("InitAction", () => {
       await initAction.execute(headlessOptions);
       expect(cleanDatabaseSpy).toHaveBeenCalled();
       expect(openFrontendSpy).not.toHaveBeenCalled();
-      expect((initAction as any).succeedSpinner).toHaveBeenCalledWith("GenLayer Localnet initialized successfully! ");
+      expect((initAction as any).succeedSpinner).toHaveBeenCalledWith(
+        "GenLayer Localnet initialized successfully! ",
+      );
       expect(ollamaUpdateSpy).toHaveBeenCalledWith("llama3");
     });
 
@@ -144,12 +171,12 @@ describe("InitAction", () => {
       const customVersion = "custom-v1";
       normalizeLocalnetVersionSpy.mockReturnValue(customVersion);
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
-      await initAction.execute({ ...defaultOptions, localnetVersion: customVersion });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
+      await initAction.execute({...defaultOptions, localnetVersion: customVersion});
       expect(normalizeLocalnetVersionSpy).toHaveBeenCalledWith(customVersion);
-      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({ LOCALNETVERSION: customVersion });
+      expect(addConfigToEnvFileSpy).toHaveBeenCalledWith({LOCALNETVERSION: customVersion});
     });
 
     test("should set defaultOllamaModel to 'llama3' if not provided in config", async () => {
@@ -157,21 +184,21 @@ describe("InitAction", () => {
       const writeConfigSpy = vi.spyOn(initAction, "writeConfig").mockImplementation(() => {});
       const ollamaUpdateSpy = vi.spyOn(OllamaAction.prototype, "updateModel").mockResolvedValue(undefined);
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["ollama"] })
-        .mockResolvedValueOnce({ ollama: "API_KEY_OLLAMA" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["ollama"]})
+        .mockResolvedValueOnce({ollama: "API_KEY_OLLAMA"});
       await initAction.execute(defaultOptions);
       expect(writeConfigSpy).toHaveBeenCalledWith("defaultOllamaModel", "llama3");
       expect(ollamaUpdateSpy).toHaveBeenCalledWith("llama3");
     });
 
     test("validates API key input for configurable provider", async () => {
-      inquirerPromptSpy.mockResolvedValueOnce({ confirmAction: true });
-      inquirerPromptSpy.mockResolvedValueOnce({ selectedLlmProviders: ["openai"] });
+      inquirerPromptSpy.mockResolvedValueOnce({confirmAction: true});
+      inquirerPromptSpy.mockResolvedValueOnce({selectedLlmProviders: ["openai"]});
       let capturedQuestion: any;
       inquirerPromptSpy.mockImplementationOnce((questions: any) => {
         capturedQuestion = questions[0];
-        return Promise.resolve({ openai: "dummy-key" });
+        return Promise.resolve({openai: "dummy-key"});
       });
       await initAction.execute(defaultOptions);
       expect(capturedQuestion).toBeDefined();
@@ -183,12 +210,12 @@ describe("InitAction", () => {
     test("validates LLM provider selection prompt", async () => {
       let capturedQuestion: any;
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
+        .mockResolvedValueOnce({confirmAction: true})
         .mockImplementationOnce((questions: any) => {
           capturedQuestion = questions[0];
-          return Promise.resolve({ selectedLlmProviders: ["openai"] });
+          return Promise.resolve({selectedLlmProviders: ["openai"]});
         })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       await initAction.execute(defaultOptions);
       expect(capturedQuestion.validate([])).toBe("You must choose at least one option.");
       expect(capturedQuestion.validate(["openai"])).toBe(true);
@@ -221,127 +248,171 @@ describe("InitAction", () => {
 
   describe("Error Handling", () => {
     test("fails if Docker is not installed", async () => {
-      checkInstallRequirementsSpy.mockResolvedValue({ git: true, docker: false });
+      checkInstallRequirementsSpy.mockResolvedValue({git: true, docker: false});
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("Docker is not installed. Please install Docker and try again.\n");
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "Docker is not installed. Please install Docker and try again.\n",
+      );
     });
 
     test("fails if checkInstallRequirements throws an error", async () => {
       const error = new Error("Install error");
       checkInstallRequirementsSpy.mockRejectedValue(error);
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", error);
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        error,
+      );
     });
 
     test("fails if version requirements are not met (both docker and node)", async () => {
       const version = "99.9.9";
-      checkVersionRequirementsSpy.mockResolvedValue({ docker: version, node: version });
+      checkVersionRequirementsSpy.mockResolvedValue({docker: version, node: version});
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith(`Docker version ${version} or higher is required. Please update Docker and try again.\nNode version ${version} or higher is required. Please update Node and try again.\n`);
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        `Docker version ${version} or higher is required. Please update Docker and try again.\nNode version ${version} or higher is required. Please update Node and try again.\n`,
+      );
     });
 
     test("fails if version requirement for docker is not met", async () => {
       const version = "99.9.9";
-      checkVersionRequirementsSpy.mockResolvedValue({ docker: version });
+      checkVersionRequirementsSpy.mockResolvedValue({docker: version});
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith(`Docker version ${version} or higher is required. Please update Docker and try again.\n`);
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        `Docker version ${version} or higher is required. Please update Docker and try again.\n`,
+      );
     });
 
     test("fails if version requirement for node is not met", async () => {
       const version = "99.9.9";
-      checkVersionRequirementsSpy.mockResolvedValue({ node: version });
+      checkVersionRequirementsSpy.mockResolvedValue({node: version});
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith(`Node version ${version} or higher is required. Please update Node and try again.\n`);
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        `Node version ${version} or higher is required. Please update Node and try again.\n`,
+      );
     });
 
     test("aborts if user does not confirm reset action", async () => {
-      inquirerPromptSpy.mockResolvedValueOnce({ confirmAction: false });
-      await initAction.execute(defaultOptions)
+      inquirerPromptSpy.mockResolvedValueOnce({confirmAction: false});
+      await initAction.execute(defaultOptions);
       expect((initAction as any).logError).toHaveBeenCalledWith(`Operation aborted!`);
     });
 
     test("fails if resetDockerContainers throws an error", async () => {
-      inquirerPromptSpy.mockResolvedValueOnce({ confirmAction: true });
+      inquirerPromptSpy.mockResolvedValueOnce({confirmAction: true});
       resetDockerContainersSpy.mockRejectedValue(new Error("Container reset error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", new Error("Container reset error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        new Error("Container reset error"),
+      );
     });
 
     test("fails if runSimulator throws an error", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       runSimulatorSpy.mockRejectedValue(new Error("Run simulator error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", new Error("Run simulator error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        new Error("Run simulator error"),
+      );
     });
 
     test("fails if waitForSimulatorToBeReady returns ERROR code", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
-      waitForSimulatorSpy.mockResolvedValue({ initialized: false, errorCode: "ERROR", errorMessage: "Initialization failed" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
+      waitForSimulatorSpy.mockResolvedValue({
+        initialized: false,
+        errorCode: "ERROR",
+        errorMessage: "Initialization failed",
+      });
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("Unable to initialize the GenLayer Localnet: Initialization failed");
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "Unable to initialize the GenLayer Localnet: Initialization failed",
+      );
     });
 
     test("fails if waitForSimulatorToBeReady returns TIMEOUT code", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
-      waitForSimulatorSpy.mockResolvedValue({ initialized: false, errorCode: "TIMEOUT", errorMessage: "Timeout" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
+      waitForSimulatorSpy.mockResolvedValue({
+        initialized: false,
+        errorCode: "TIMEOUT",
+        errorMessage: "Timeout",
+      });
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("The localnet is taking too long to initialize. Please try again after the localnet is ready.");
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "The localnet is taking too long to initialize. Please try again after the localnet is ready.",
+      );
     });
 
     test("fails if deleteAllValidators throws an error", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       deleteAllValidatorsSpy.mockRejectedValue(new Error("Validator deletion error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", expect.any(Error));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        expect.any(Error),
+      );
     });
 
     test("fails if createRandomValidators throws an error", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       createRandomValidatorsSpy.mockRejectedValue(new Error("Validator creation error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", Error("Validator creation error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        Error("Validator creation error"),
+      );
     });
 
     test("fails if cleanDatabase throws an error when resetDb is true", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       cleanDatabaseSpy.mockRejectedValue(new Error("Database error"));
-      const optionsWithResetDb: InitActionOptions = { ...defaultOptions, resetDb: true };
+      const optionsWithResetDb: InitActionOptions = {...defaultOptions, resetDb: true};
       await initAction.execute(optionsWithResetDb);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", new Error("Database error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        new Error("Database error"),
+      );
     });
 
     test("fails if openFrontend throws an error", async () => {
       inquirerPromptSpy
-        .mockResolvedValueOnce({ confirmAction: true })
-        .mockResolvedValueOnce({ selectedLlmProviders: ["openai"] })
-        .mockResolvedValueOnce({ openai: "API_KEY_OPENAI" });
+        .mockResolvedValueOnce({confirmAction: true})
+        .mockResolvedValueOnce({selectedLlmProviders: ["openai"]})
+        .mockResolvedValueOnce({openai: "API_KEY_OPENAI"});
       openFrontendSpy.mockRejectedValue(new Error("Frontend error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", new Error("Frontend error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        new Error("Frontend error"),
+      );
     });
 
     test("catches and logs unexpected errors", async () => {
       inquirerPromptSpy.mockRejectedValueOnce(new Error("Unexpected prompt error"));
       await initAction.execute(defaultOptions);
-      expect((initAction as any).failSpinner).toHaveBeenCalledWith("An error occurred during initialization.", new Error("Unexpected prompt error"));
+      expect((initAction as any).failSpinner).toHaveBeenCalledWith(
+        "An error occurred during initialization.",
+        new Error("Unexpected prompt error"),
+      );
     });
   });
-});
+});

package/tests/actions/start.test.ts

@@ -1,7 +1,7 @@
-import { describe, beforeEach, afterEach, test, expect, vi, Mock } from "vitest";
+import {describe, beforeEach, afterEach, test, expect, vi, Mock} from "vitest";
 import inquirer from "inquirer";
-import { StartAction, StartActionOptions } from "../../src/commands/general/start";
-import { SimulatorService } from "../../src/lib/services/simulator";
+import {StartAction, StartActionOptions} from "../../src/commands/general/start";
+import {SimulatorService} from "../../src/lib/services/simulator";
 
 vi.mock("../../src/lib/services/simulator");
 vi.mock("inquirer");
@@ -18,7 +18,7 @@ describe("StartAction", () => {
     startAction = new StartAction();
     startAction["simulatorService"] = mockSimulatorService;
 
-    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({ initialized: true });
+    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({initialized: true});
     mockSimulatorService.stopDockerContainers = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.getAiProvidersOptions = vi.fn().mockResolvedValue(undefined);
 
@@ -43,9 +43,9 @@ describe("StartAction", () => {
 
   test("should check if localnet is running and proceed without confirmation when not running", async () => {
     mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(false);
-    
+
     await startAction.execute(defaultOptions);
-    
+
     expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
     expect(mockConfirmPrompt).not.toHaveBeenCalled();
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
@@ -53,11 +53,13 @@ describe("StartAction", () => {
 
   test("should prompt for confirmation when localnet is already running", async () => {
     mockSimulatorService.isLocalnetRunning = vi.fn().mockResolvedValue(true);
-    
+
     await startAction.execute(defaultOptions);
-    
+
     expect(mockSimulatorService.isLocalnetRunning).toHaveBeenCalled();
-    expect(mockConfirmPrompt).toHaveBeenCalledWith("GenLayer Localnet is already running. Do you want to proceed?");
+    expect(mockConfirmPrompt).toHaveBeenCalledWith(
+      "GenLayer Localnet is already running. Do you want to proceed?",
+    );
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
   });
 
@@ -71,13 +73,17 @@ describe("StartAction", () => {
     expect(startAction["startSpinner"]).toHaveBeenCalledWith("Checking CLI version...");
     expect(mockSimulatorService.checkCliVersion).toHaveBeenCalled();
 
-    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Starting GenLayer Localnet (keeping the existing validators)...");
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith(
+      "Starting GenLayer Localnet (keeping the existing validators)...",
+    );
     expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
 
     expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Waiting for the simulator to be ready...");
     expect(mockSimulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
 
-    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith("GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.");
+    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.",
+    );
   });
 
   test("should fail when simulator fails to start", async () => {
@@ -90,15 +96,20 @@ describe("StartAction", () => {
   });
 
   test("should fail when waiting for simulator initialization times out", async () => {
-    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({ initialized: false, errorCode: "TIMEOUT" });
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
+      initialized: false,
+      errorCode: "TIMEOUT",
+    });
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("The simulator is taking too long to initialize. Please try again later.");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "The simulator is taking too long to initialize. Please try again later.",
+    );
   });
 
   test("should reset the database if resetDb is true", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetDb: true };
+    const options: StartActionOptions = {...defaultOptions, resetDb: true};
 
     mockSimulatorService.cleanDatabase = vi.fn().mockResolvedValue(undefined);
 
@@ -109,13 +120,13 @@ describe("StartAction", () => {
   });
 
   test("should initialize validators when resetValidators is true", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetValidators: true };
+    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
 
     mockSimulatorService.deleteAllValidators = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.createRandomValidators = vi.fn().mockResolvedValue(undefined);
     mockSimulatorService.getAiProvidersOptions = vi.fn().mockReturnValue(["Provider1", "Provider2"]);
 
-    vi.mocked(inquirer.prompt).mockResolvedValue({ selectedLlmProviders: ["Provider1"] });
+    vi.mocked(inquirer.prompt).mockResolvedValue({selectedLlmProviders: ["Provider1"]});
 
     await startAction.execute(options);
 
@@ -125,13 +136,18 @@ describe("StartAction", () => {
   });
 
   test("should fail when initializing validators fails", async () => {
-    const options: StartActionOptions = { ...defaultOptions, resetValidators: true };
+    const options: StartActionOptions = {...defaultOptions, resetValidators: true};
 
-    mockSimulatorService.deleteAllValidators = vi.fn().mockRejectedValue(new Error("Failed to delete validators"));
+    mockSimulatorService.deleteAllValidators = vi
+      .fn()
+      .mockRejectedValue(new Error("Failed to delete validators"));
 
     await startAction.execute(options);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the validators", expect.any(Error));
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Unable to initialize the validators",
+      expect.any(Error),
+    );
   });
 
   test("should open frontend when not in headless mode", async () => {
@@ -165,7 +181,9 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("The simulator is taking too long to initialize. Please try again later.");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "The simulator is taking too long to initialize. Please try again later.",
+    );
   });
 
   test("should log error message if simulator fails to initialize with ERROR code", async () => {
@@ -177,7 +195,10 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the GenLayer simulator.", "Initialization failed");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Unable to initialize the GenLayer simulator.",
+      "Initialization failed",
+    );
   });
 
   test("catches and logs error if waitForSimulatorToBeReady throws an exception", async () => {
@@ -186,14 +207,17 @@ describe("StartAction", () => {
 
     await startAction.execute(defaultOptions);
 
-    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error waiting for the simulator to be ready", errorMsg);
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error waiting for the simulator to be ready",
+      errorMsg,
+    );
   });
 
   test("should not append frontend URL when in headless mode", async () => {
-    await startAction.execute({ ...defaultOptions, headless: true });
+    await startAction.execute({...defaultOptions, headless: true});
 
     expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
-      "GenLayer simulator initialized successfully! "
+      "GenLayer simulator initialized successfully! ",
     );
   });