genlayer 0.18.0 → 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/setNetwork.test.ts

@@ -0,0 +1,199 @@
+import {describe, test, vi, beforeEach, afterEach, expect} from "vitest";
+import {NetworkActions} from "../../src/commands/network/setNetwork";
+import {ConfigFileManager} from "../../src/lib/config/ConfigFileManager";
+import inquirer from "inquirer";
+import {localnet, studionet, testnetAsimov} from "genlayer-js/chains";
+
+vi.mock("../../src/lib/config/ConfigFileManager");
+vi.mock("inquirer");
+
+describe("NetworkActions", () => {
+  let networkActions: NetworkActions;
+
+  beforeEach(() => {
+    networkActions = new NetworkActions();
+    vi.clearAllMocks();
+
+    vi.spyOn(networkActions as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(networkActions as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(networkActions as any, "writeConfig").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("setNetwork method sets network by valid name", async () => {
+    await networkActions.setNetwork(localnet.name);
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(localnet));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${localnet.name}`,
+    );
+  });
+
+  test("setNetwork method sets network by valid alias", async () => {
+    await networkActions.setNetwork("localnet");
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(localnet));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${localnet.name}`,
+    );
+  });
+
+  test("setNetwork method sets studionet by name", async () => {
+    await networkActions.setNetwork(studionet.name);
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(studionet));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${studionet.name}`,
+    );
+  });
+
+  test("setNetwork method sets studionet by alias", async () => {
+    await networkActions.setNetwork("studionet");
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(studionet));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${studionet.name}`,
+    );
+  });
+
+  test("setNetwork method sets testnet-asimov by name", async () => {
+    await networkActions.setNetwork(testnetAsimov.name);
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(testnetAsimov));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${testnetAsimov.name}`,
+    );
+  });
+
+  test("setNetwork method sets testnet-asimov by alias", async () => {
+    await networkActions.setNetwork("testnet-asimov");
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith("network", JSON.stringify(testnetAsimov));
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${testnetAsimov.name}`,
+    );
+  });
+
+  test("setNetwork method fails for invalid network name", async () => {
+    await networkActions.setNetwork("invalidNetwork");
+
+    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network invalidNetwork not found");
+    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
+    expect(networkActions["succeedSpinner"]).not.toHaveBeenCalled();
+  });
+
+  test("setNetwork method fails for empty network name", async () => {
+    await networkActions.setNetwork("");
+
+    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network  not found");
+    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
+    expect(networkActions["succeedSpinner"]).not.toHaveBeenCalled();
+  });
+
+  test("setNetwork method prompts user when no network name provided", async () => {
+    const mockSelectedNetwork = {
+      name: localnet.name,
+      alias: "localnet",
+      value: localnet,
+    };
+
+    vi.mocked(inquirer.prompt).mockResolvedValue({
+      selectedNetwork: mockSelectedNetwork,
+    });
+
+    await networkActions.setNetwork();
+
+    expect(inquirer.prompt).toHaveBeenCalledWith([
+      {
+        type: "list",
+        name: "selectedNetwork",
+        message: "Select which network do you want to use:",
+        choices: [
+          {
+            name: localnet.name,
+            alias: "localnet",
+            value: localnet,
+          },
+          {
+            name: studionet.name,
+            alias: "studionet",
+            value: studionet,
+          },
+          {
+            name: testnetAsimov.name,
+            alias: "testnet-asimov",
+            value: testnetAsimov,
+          },
+        ],
+      },
+    ]);
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
+      "network",
+      JSON.stringify(mockSelectedNetwork),
+    );
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${mockSelectedNetwork.name}`,
+    );
+  });
+
+  test("setNetwork method handles interactive selection of studionet", async () => {
+    const mockSelectedNetwork = {
+      name: studionet.name,
+      alias: "studionet",
+      value: studionet,
+    };
+
+    vi.mocked(inquirer.prompt).mockResolvedValue({
+      selectedNetwork: mockSelectedNetwork,
+    });
+
+    await networkActions.setNetwork();
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
+      "network",
+      JSON.stringify(mockSelectedNetwork),
+    );
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${mockSelectedNetwork.name}`,
+    );
+  });
+
+  test("setNetwork method handles interactive selection of testnet-asimov", async () => {
+    const mockSelectedNetwork = {
+      name: testnetAsimov.name,
+      alias: "testnet-asimov",
+      value: testnetAsimov,
+    };
+
+    vi.mocked(inquirer.prompt).mockResolvedValue({
+      selectedNetwork: mockSelectedNetwork,
+    });
+
+    await networkActions.setNetwork();
+
+    expect(networkActions["writeConfig"]).toHaveBeenCalledWith(
+      "network",
+      JSON.stringify(mockSelectedNetwork),
+    );
+    expect(networkActions["succeedSpinner"]).toHaveBeenCalledWith(
+      `Network successfully set to ${mockSelectedNetwork.name}`,
+    );
+  });
+
+  test("setNetwork method handles case-sensitive network names", async () => {
+    await networkActions.setNetwork("LOCALNET");
+
+    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network LOCALNET not found");
+    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
+  });
+
+  test("setNetwork method handles partial network names", async () => {
+    await networkActions.setNetwork("local");
+
+    expect(networkActions["failSpinner"]).toHaveBeenCalledWith("Network local not found");
+    expect(networkActions["writeConfig"]).not.toHaveBeenCalled();
+  });
+});