genlayer 0.12.1 → 0.12.2-beta.0

package/tests/actions/ollama.test.ts

@@ -1,7 +1,6 @@
 import { describe, test, vi, beforeEach, afterEach, expect, Mock } from "vitest";
 import { OllamaAction } from "../../src/commands/update/ollama";
 import { rpcClient } from "../../src/lib/clients/jsonRpcClient";
-
 import Docker from "dockerode";
 
 vi.mock("dockerode");
@@ -37,6 +36,11 @@ describe("OllamaAction", () => {
     } as unknown as Docker.Container);
 
     Docker.prototype.getContainer = mockGetContainer;
+
+    vi.spyOn(ollamaAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(ollamaAction as any, "failSpinner").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -49,6 +53,7 @@ describe("OllamaAction", () => {
       config: { key: "value" },
       plugin_config: { pluginKey: "pluginValue" },
     };
+
     vi.mocked(rpcClient.request).mockResolvedValueOnce({
       result: [mockProvider],
     });
@@ -62,10 +67,9 @@ describe("OllamaAction", () => {
       }
     });
 
-    console.log = vi.fn();
-
     await ollamaAction.updateModel("mocked_model");
 
+    expect(ollamaAction["startSpinner"]).toHaveBeenCalledWith(`Updating model "mocked_model"...`);
     expect(mockGetContainer).toHaveBeenCalledWith("ollama");
     expect(mockExec).toHaveBeenCalledWith({
       Cmd: ["ollama", "pull", "mocked_model"],
@@ -73,10 +77,8 @@ describe("OllamaAction", () => {
       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));
-    expect(console.log).toHaveBeenCalledWith("Mocked output success");
-    expect(console.log).toHaveBeenCalledWith('Model "mocked_model" updated successfully');
+    expect(ollamaAction["setSpinnerText"]).toHaveBeenCalledWith("Mocked output success");
+    expect(ollamaAction["succeedSpinner"]).toHaveBeenCalledWith(`Model "mocked_model" updated successfully`);
   });
 
   test("should remove the model using 'rm'", async () => {
@@ -89,10 +91,9 @@ describe("OllamaAction", () => {
       }
     });
 
-    console.log = vi.fn();
-
     await ollamaAction.removeModel("mocked_model");
 
+    expect(ollamaAction["startSpinner"]).toHaveBeenCalledWith(`Executing 'rm' command on model "mocked_model"...`);
     expect(mockGetContainer).toHaveBeenCalledWith("ollama");
     expect(mockExec).toHaveBeenCalledWith({
       Cmd: ["ollama", "rm", "mocked_model"],
@@ -100,10 +101,8 @@ describe("OllamaAction", () => {
       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));
-    expect(console.log).toHaveBeenCalledWith("Mocked output success");
-    expect(console.log).toHaveBeenCalledWith('Model "mocked_model" removed successfully');
+    expect(ollamaAction["setSpinnerText"]).toHaveBeenCalledWith("Mocked output success");
+    expect(ollamaAction["succeedSpinner"]).toHaveBeenCalledWith(`Model "mocked_model" removed successfully`);
   });
 
   test("should log an error if an exception occurs during 'pull'", async () => {
@@ -112,48 +111,26 @@ describe("OllamaAction", () => {
       config: { key: "value" },
       plugin_config: { pluginKey: "pluginValue" },
     };
+
     vi.mocked(rpcClient.request).mockResolvedValueOnce({
       result: [mockProvider],
     });
 
     const error = new Error("Mocked error");
-    mockGetContainer.mockReturnValueOnce(
-      {
-        exec: () => {
-          throw new Error("Mocked error");
-        }
-      }
-    );
-    console.error = vi.fn();
+    mockExec.mockRejectedValue(error);
 
     await ollamaAction.updateModel("mocked_model");
 
-    expect(mockGetContainer).toHaveBeenCalledWith("ollama");
-    expect(console.error).toHaveBeenCalledWith(
-      'Error executing command "pull" on model "mocked_model":',
-      error
-    );
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error executing command "pull" on model "mocked_model"`, error);
   });
 
   test("should log an error if an exception occurs during 'rm'", async () => {
     const error = new Error("Mocked error");
-    mockGetContainer.mockReturnValueOnce(
-      {
-        exec: () => {
-          throw new Error("Mocked error");
-        }
-      }
-    );
-
-    console.error = vi.fn();
+    mockExec.mockRejectedValue(error);
 
     await ollamaAction.removeModel("mocked_model");
 
-    expect(mockGetContainer).toHaveBeenCalledWith("ollama");
-    expect(console.error).toHaveBeenCalledWith(
-      'Error executing command "rm" on model "mocked_model":',
-      error
-    );
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error executing command "rm" on model "mocked_model"`, error);
   });
 
   test("should throw an error if no 'ollama' provider exists during updateModel", async () => {
@@ -161,21 +138,14 @@ describe("OllamaAction", () => {
       result: [],
     });
 
-    const modelName = "mocked_model";
+    await ollamaAction.updateModel("mocked_model");
 
-    await expect(ollamaAction.updateModel(modelName)).rejects.toThrowError(
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(
       "No existing 'ollama' provider found. Unable to add/update a model."
     );
-
-    expect(rpcClient.request).toHaveBeenCalledWith({
-      method: "sim_getProvidersAndModels",
-      params: [],
-    });
   });
 
   test("should reject with an error if success is not set to true", async () => {
-    console.error = vi.fn();
-
     const mockProvider = {
       plugin: "ollama",
       config: { key: "value" },
@@ -195,14 +165,29 @@ describe("OllamaAction", () => {
       }
     });
 
-    console.log = vi.fn();
-    console.error = vi.fn();
-
     await ollamaAction.updateModel("mocked_model");
 
-    expect(console.error).toHaveBeenCalledWith(
-      'Error executing command "pull" on model "mocked_model":', 'internal error'
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(
+      `Failed to execute 'pull' on model "mocked_model".`
     );
   });
 
-});
+  test("should log an error if an exception occurs inside updateModel", async () => {
+    const mockError = new Error("Mocked error");
+
+    vi.mocked(rpcClient.request).mockRejectedValue(mockError);
+
+    await ollamaAction.updateModel("mocked_model");
+
+    expect(ollamaAction["failSpinner"]).toHaveBeenCalledWith(`Error updating model "mocked_model"`, mockError);
+  });
+
+  test("should call get config if modelName is empty", async () => {
+    const defaultModel = "default_model";
+    vi.spyOn(ollamaAction as any, "getConfig").mockReturnValue({ defaultOllamaModel: defaultModel });
+
+    await ollamaAction.updateModel("");
+    expect(ollamaAction.getConfig).toHaveBeenCalledTimes(1);
+  });
+
+});

package/tests/actions/start.test.ts

@@ -1,175 +1,174 @@
 import { describe, beforeEach, afterEach, test, expect, vi, Mock } from "vitest";
 import inquirer from "inquirer";
-import { startAction, StartActionOptions } from "../../src/commands/general/start";
-import { ISimulatorService } from "../../src/lib/interfaces/ISimulatorService";
+import { StartAction, StartActionOptions } from "../../src/commands/general/start";
+import { SimulatorService } from "../../src/lib/services/simulator";
 
-describe("startAction - Additional Tests", () => {
-  let simulatorService: ISimulatorService;
-  let logSpy: ReturnType<typeof vi.spyOn>;
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  let promptSpy: ReturnType<any>;
+vi.mock("../../src/lib/services/simulator");
+vi.mock("inquirer");
 
-  const defaultOptions: StartActionOptions = {
-    resetValidators: false,
-    numValidators: 5,
-    headless: false,
-    resetDb: false
-  };
+describe("StartAction", () => {
+  let startAction: StartAction;
+  let mockSimulatorService: SimulatorService;
 
   beforeEach(() => {
-    logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
-    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-    promptSpy = vi.spyOn(inquirer, "prompt");
-
-    simulatorService = {
-      updateSimulator: vi.fn().mockResolvedValue(undefined),
-      runSimulator: vi.fn().mockResolvedValue(undefined),
-      waitForSimulatorToBeReady: vi.fn().mockResolvedValue({ initialized: true }),
-      deleteAllValidators: vi.fn().mockResolvedValue(undefined),
-      createRandomValidators: vi.fn().mockResolvedValue(undefined),
-      openFrontend: vi.fn().mockResolvedValue(undefined),
-      setSimulatorLocation: vi.fn().mockResolvedValue(undefined),
-      setComposeOptions: vi.fn(),
-      checkCliVersion: vi.fn(),
-      getAiProvidersOptions: vi.fn(() => [
-        { name: "Provider A", value: "providerA" },
-        { name: "Provider B", value: "providerB" },
-      ]),
-      getFrontendUrl: vi.fn(() => "http://localhost:8080"),
-      cleanDatabase: vi.fn().mockResolvedValue(undefined),
-    } as unknown as ISimulatorService;
+    vi.clearAllMocks();
+
+    mockSimulatorService = new SimulatorService();
+    startAction = new StartAction();
+    startAction["simulatorService"] = mockSimulatorService;
+
+    mockSimulatorService.waitForSimulatorToBeReady = vi.fn().mockResolvedValue({ initialized: true });
+
+    vi.spyOn(startAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(startAction as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(startAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(startAction as any, "failSpinner").mockImplementation(() => {});
   });
 
   afterEach(() => {
     vi.restoreAllMocks();
   });
 
-  test("runs successfully with default options and keeps existing validators", async () => {
-    await startAction(defaultOptions, simulatorService);
+  const defaultOptions: StartActionOptions = {
+    resetValidators: false,
+    numValidators: 5,
+    headless: false,
+    resetDb: false,
+  };
+
+  test("should start the simulator successfully", async () => {
+    mockSimulatorService.checkCliVersion = vi.fn().mockResolvedValue(undefined);
+    mockSimulatorService.runSimulator = vi.fn().mockResolvedValue(undefined);
+    mockSimulatorService.getFrontendUrl = vi.fn().mockReturnValue("http://localhost:8080");
+
+    await startAction.execute(defaultOptions);
+
+    expect(startAction["startSpinner"]).toHaveBeenCalledWith("Checking CLI version...");
+    expect(mockSimulatorService.checkCliVersion).toHaveBeenCalled();
 
-    expect(simulatorService.runSimulator).toHaveBeenCalled();
-    expect(simulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Starting GenLayer Localnet (keeping the existing validators)...");
+    expect(mockSimulatorService.runSimulator).toHaveBeenCalled();
 
-    expect(logSpy).toHaveBeenCalledWith("Starting GenLayer simulator keeping the existing validators");
-    expect(logSpy).toHaveBeenCalledWith("Simulator is running!");
-    expect(logSpy).toHaveBeenCalledWith("GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.");
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Waiting for the simulator to be ready...");
+    expect(mockSimulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
 
-    expect(simulatorService.openFrontend).toHaveBeenCalled();
+    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith("GenLayer simulator initialized successfully! Go to http://localhost:8080 in your browser to access it.");
   });
 
-  test("runs successfully with custom options and keeps existing validators", async () => {
-    await startAction({...defaultOptions, headless: true, resetDb: true}, simulatorService);
+  test("should fail when simulator fails to start", async () => {
+    const errorMsg = new Error("runSimulator error");
+    (mockSimulatorService.runSimulator as Mock).mockRejectedValueOnce(errorMsg);
+
+    await startAction.execute(defaultOptions);
+
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error starting the simulator", errorMsg);
+  });
 
-    expect(simulatorService.runSimulator).toHaveBeenCalled();
-    expect(simulatorService.waitForSimulatorToBeReady).toHaveBeenCalled();
+  test("should fail when waiting for simulator initialization times out", async () => {
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({ initialized: false, errorCode: "TIMEOUT" });
 
-    expect(logSpy).toHaveBeenCalledWith("Starting GenLayer simulator keeping the existing validators");
+    await startAction.execute(defaultOptions);
 
-    expect(logSpy).toHaveBeenCalledWith("Simulator is running!");
-    expect(logSpy).toHaveBeenCalledWith("GenLayer simulator initialized successfully! ");
+    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 };
 
-  test("logs error and stops if runSimulator fails", async () => {
-    const errorMsg = new Error("runSimulator error");
-    (simulatorService.runSimulator as Mock).mockRejectedValueOnce(errorMsg);
+    mockSimulatorService.cleanDatabase = vi.fn().mockResolvedValue(undefined);
 
-    await startAction(defaultOptions, simulatorService);
+    await startAction.execute(options);
 
-    expect(errorSpy).toHaveBeenCalledWith(errorMsg);
-    expect(simulatorService.waitForSimulatorToBeReady).not.toHaveBeenCalled();
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Resetting database...");
+    expect(mockSimulatorService.cleanDatabase).toHaveBeenCalled();
   });
 
-  test("handles resetfValidators correctly by deleting and creating new validators", async () => {
-    promptSpy.mockResolvedValueOnce({ selectedLlmProviders: ["providerA"] });
-    const optionsWithReset: StartActionOptions = { ...defaultOptions, resetValidators: true };
+  test("should initialize validators when resetValidators is true", async () => {
+    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"]);
 
-    await startAction(optionsWithReset, simulatorService);
+    vi.mocked(inquirer.prompt).mockResolvedValue({ selectedLlmProviders: ["Provider1"] });
 
-    expect(simulatorService.deleteAllValidators).toHaveBeenCalled();
-    expect(simulatorService.createRandomValidators).toHaveBeenCalledWith(5, ["providerA"]);
-    expect(logSpy).toHaveBeenCalledWith("New random validators successfully created...");
+    await startAction.execute(options);
+
+    expect(startAction["setSpinnerText"]).toHaveBeenCalledWith("Initializing validators...");
+    expect(mockSimulatorService.deleteAllValidators).toHaveBeenCalled();
+    expect(mockSimulatorService.createRandomValidators).toHaveBeenCalledWith(5, ["Provider1"]);
   });
 
-  test("logs error if deleteAllValidators fails when resetValidators is true", async () => {
-    const errorMsg = new Error("deleteAllValidators error");
-    (simulatorService.deleteAllValidators as Mock).mockRejectedValueOnce(errorMsg);
-    const optionsWithReset: StartActionOptions = { ...defaultOptions, resetValidators: true };
+  test("should fail when initializing validators fails", async () => {
+    const options: StartActionOptions = { ...defaultOptions, resetValidators: true };
+
+    mockSimulatorService.deleteAllValidators = vi.fn().mockRejectedValue(new Error("Failed to delete validators"));
 
-    await startAction(optionsWithReset, simulatorService);
+    await startAction.execute(options);
 
-    expect(errorSpy).toHaveBeenCalledWith("Unable to initialize the validators.");
-    expect(errorSpy).toHaveBeenCalledWith(errorMsg);
-    expect(simulatorService.createRandomValidators).not.toHaveBeenCalled();
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the validators", expect.any(Error));
   });
 
-  test("prompts for LLM providers and validates at least one option is selected", async () => {
-    const aiProviders = simulatorService.getAiProvidersOptions(false);
-    expect(aiProviders).toEqual([
-      { name: "Provider A", value: "providerA" },
-      { name: "Provider B", value: "providerB" },
-    ]);
+  test("should open frontend when not in headless mode", async () => {
+    mockSimulatorService.checkCliVersion = vi.fn().mockResolvedValue(undefined);
+    mockSimulatorService.runSimulator = vi.fn().mockResolvedValue(undefined);
+    mockSimulatorService.getFrontendUrl = vi.fn().mockReturnValue("http://localhost:8080");
+    mockSimulatorService.openFrontend = vi.fn().mockResolvedValue(undefined);
 
-    promptSpy.mockImplementation(async (questions: any) => {
-      const validateFunction = questions[0].validate;
+    await startAction.execute(defaultOptions);
 
-      expect(validateFunction([])).toBe("You must choose at least one option.");
-      expect(validateFunction(["providerA"])).toBe(true);
+    expect(startAction["startSpinner"]).toHaveBeenCalledWith("Opening frontend...");
+    expect(mockSimulatorService.openFrontend).toHaveBeenCalled();
+    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith("Frontend opened successfully");
+  });
 
-      return { selectedLlmProviders: ["providerA"] };
-    });
+  test("should handle errors when opening frontend", async () => {
+    const errorMsg = new Error("Failed to open frontend");
+    (mockSimulatorService.openFrontend as Mock).mockRejectedValueOnce(errorMsg);
 
-    const optionsWithReset: StartActionOptions = { ...defaultOptions, resetValidators: true };
-    await startAction(optionsWithReset, simulatorService);
+    await startAction.execute(defaultOptions);
 
-    expect(promptSpy).toHaveBeenCalled();
-    expect(simulatorService.createRandomValidators).toHaveBeenCalledWith(5, ["providerA"]);
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error opening the frontend", errorMsg);
   });
 
-  test("logs specific message if waitForSimulatorToBeReady returns TIMEOUT errorCode", async () => {
-    (simulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
+  test("should log specific message if waitForSimulatorToBeReady returns TIMEOUT errorCode", async () => {
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
       initialized: false,
       errorCode: "TIMEOUT",
       errorMessage: "Initialization timed out",
     });
 
-    await startAction(defaultOptions, simulatorService);
+    await startAction.execute(defaultOptions);
 
-    expect(errorSpy).toHaveBeenCalledWith(
-      "The simulator is taking too long to initialize. Please try again after the simulator is ready."
-    );
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("The simulator is taking too long to initialize. Please try again later.");
   });
 
-  test("logs error message if simulator fails to initialize with ERROR code", async () => {
-    (simulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
+  test("should log error message if simulator fails to initialize with ERROR code", async () => {
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockResolvedValue({
       initialized: false,
       errorCode: "ERROR",
       errorMessage: "Initialization failed",
     });
 
-    await startAction(defaultOptions, simulatorService);
+    await startAction.execute(defaultOptions);
 
-    expect(logSpy).toHaveBeenCalledWith("Initialization failed");
-    expect(errorSpy).toHaveBeenCalledWith("Unable to initialize the GenLayer simulator. Please try again.");
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Unable to initialize the GenLayer simulator.", "Initialization failed");
   });
 
   test("catches and logs error if waitForSimulatorToBeReady throws an exception", async () => {
     const errorMsg = new Error("Unexpected initialization error");
-    (simulatorService.waitForSimulatorToBeReady as Mock).mockRejectedValueOnce(errorMsg);
+    (mockSimulatorService.waitForSimulatorToBeReady as Mock).mockRejectedValueOnce(errorMsg);
 
-    await startAction(defaultOptions, simulatorService);
+    await startAction.execute(defaultOptions);
 
-    expect(errorSpy).toHaveBeenCalledWith(errorMsg);
+    expect(startAction["failSpinner"]).toHaveBeenCalledWith("Error waiting for the simulator to be ready", errorMsg);
   });
 
-  test("catches and logs error if openFrontend throws an exception", async () => {
-    const errorMsg = new Error("Failed to open frontend");
-    (simulatorService.openFrontend as Mock).mockImplementationOnce(() => {
-      throw errorMsg;
-    });
+  test("should not append frontend URL when in headless mode", async () => {
+    await startAction.execute({ ...defaultOptions, headless: true });
 
-    await startAction(defaultOptions, simulatorService);
-
-    expect(errorSpy).toHaveBeenCalledWith(errorMsg);
+    expect(startAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "GenLayer simulator initialized successfully! "
+    );
   });
 });

package/tests/actions/stop.test.ts

@@ -2,6 +2,8 @@ import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
 import { StopAction } from "../../src/commands/general/stop";
 import { SimulatorService } from "../../src/lib/services/simulator";
 import { ISimulatorService } from "../../src/lib/interfaces/ISimulatorService";
+import chalk from "chalk";
+
 import inquirer from "inquirer";
 
 vi.mock("../../src/lib/services/simulator");
@@ -22,6 +24,10 @@ describe("StopAction", () => {
 
     stopAction = new StopAction();
     (stopAction as any).simulatorService = mockSimulatorService;
+
+    vi.spyOn(stopAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(stopAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(stopAction as any, "failSpinner").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -37,22 +43,35 @@ describe("StopAction", () => {
       {
         type: "confirm",
         name: "confirmAction",
-        message: "Are you sure you want to stop all running GenLayer containers? This will halt all active processes.",
+        message: chalk.yellow("Are you sure you want to stop all running GenLayer containers? This will halt all active processes."),
         default: true,
       },
     ]);
     expect(mockSimulatorService.stopDockerContainers).toHaveBeenCalled();
+    expect(stopAction["succeedSpinner"]).toHaveBeenCalledWith(
+      "All running GenLayer containers have been successfully stopped."
+    );
   });
 
   test("should abort if user cancels", async () => {
     vi.mocked(inquirer.prompt).mockResolvedValue({ confirmAction: false });
 
-    console.log = vi.fn();
-
     await stopAction.stop();
 
     expect(inquirer.prompt).toHaveBeenCalled();
-    expect(console.log).toHaveBeenCalledWith("Operation aborted!");
     expect(mockSimulatorService.stopDockerContainers).not.toHaveBeenCalled();
   });
+
+  test("should handle errors and call failSpinner", async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValue({ confirmAction: true });
+    const error = new Error("Test Error");
+    mockSimulatorService.stopDockerContainers = vi.fn().mockRejectedValue(error);
+
+    await stopAction.stop();
+
+    expect(stopAction["failSpinner"]).toHaveBeenCalledWith(
+      "An error occurred while stopping the containers.",
+      error
+    );
+  });
 });