genlayer 0.6.0 → 0.8.0

package/.env.example

@@ -69,3 +69,4 @@ VALIDATORS_CONFIG_JSON=''
 
 
 VSCODEDEBUG="false"
+LOCALNETVERSION="latest"

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 
 
+## 0.8.0 (2024-12-11)
+
+
+### Features
+
+* implement config command ([#149](https://github.com/yeagerai/genlayer-cli/issues/149)) ([cc0f2ca](https://github.com/yeagerai/genlayer-cli/commit/cc0f2caee2c55f00efc7da0671663827a69be557))
+
+## 0.7.0 (2024-12-09)
+
+
+### Features
+
+* adding localnet version option on init ([#151](https://github.com/yeagerai/genlayer-cli/issues/151)) ([a7bf419](https://github.com/yeagerai/genlayer-cli/commit/a7bf41986e89e8db95003df290d381e77dad127f))
+
 ## 0.6.0 (2024-12-03)
 
 

package/dist/index.js

@@ -50858,7 +50858,7 @@ var {
 } = import_index.default;
 
 // package.json
-var version = "0.6.0";
+var version = "0.8.0";
 var package_default = {
   name: "genlayer",
   version,
@@ -51817,6 +51817,18 @@ Run npm install -g genlayer to update
       return true;
     });
   }
+  normalizeLocalnetVersion(version3) {
+    if (!version3.startsWith("v")) {
+      version3 = "v" + version3;
+    }
+    const versionRegex = /^v(\d+)\.(\d+)\.(\d+)(-.+)?$/;
+    const match = version3.match(versionRegex);
+    if (!match) {
+      console.error("Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix");
+      process.exit(1);
+    }
+    return version3;
+  }
 };
 var simulator_default = new SimulatorService();
 
@@ -54427,6 +54439,10 @@ function getVersionErrorMessage({ docker, node }) {
 function initAction(options, simulatorService) {
   return __async(this, null, function* () {
     simulatorService.setComposeOptions(options.headless);
+    let localnetVersion = options.localnetVersion;
+    if (localnetVersion !== "latest") {
+      localnetVersion = simulatorService.normalizeLocalnetVersion(localnetVersion);
+    }
     yield simulatorService.checkCliVersion();
     try {
       const requirementsInstalled = yield simulatorService.checkInstallRequirements();
@@ -54512,6 +54528,7 @@ function initAction(options, simulatorService) {
     }
     console.log("Configuring GenLayer Simulator environment...");
     simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+    simulatorService.addConfigToEnvFile({ LOCALNETVERSION: localnetVersion });
     console.log("Running the GenLayer Simulator...");
     try {
       yield simulatorService.runSimulator();
@@ -54646,7 +54663,7 @@ function startAction(options, simulatorService) {
 
 // src/commands/general/index.ts
 function initializeGeneralCommands(program2) {
-  program2.command("init").description("Initialize the GenLayer Environment").option("--numValidators <numValidators>", "Number of validators", "5").option("--headless", "Headless mode", false).option("--reset-db", "Reset Database", false).action((options) => initAction(options, simulator_default));
+  program2.command("init").description("Initialize the GenLayer Environment").option("--numValidators <numValidators>", "Number of validators", "5").option("--headless", "Headless mode", false).option("--reset-db", "Reset Database", false).option("--localnet-version <localnetVersion>", "Select a specific localnet version", "latest").action((options) => initAction(options, simulator_default));
   program2.command("up").description("Starts GenLayer's simulator").option("--reset-validators", "Remove all current validators and create new random ones", false).option("--numValidators <numValidators>", "Number of validators", "5").option("--headless", "Headless mode", false).option("--reset-db", "Reset Database", false).action((options) => startAction(options, simulator_default));
   return program2;
 }
@@ -78269,11 +78286,62 @@ function initializeKeygenCommands(program2) {
   return program2;
 }
 
+// src/commands/config/getSetReset.ts
+var ConfigActions = class {
+  constructor() {
+    __publicField(this, "configManager");
+    this.configManager = new ConfigFileManager();
+  }
+  set(keyValue) {
+    const [key, value] = keyValue.split("=");
+    if (!key || value === void 0) {
+      console.error("Invalid format. Use key=value.");
+      process.exit(1);
+    }
+    this.configManager.writeConfig(key, value);
+    console.log(`Configuration updated: ${key}=${value}`);
+  }
+  get(key) {
+    if (key) {
+      const value = this.configManager.getConfigByKey(key);
+      if (value === null) {
+        console.log(`No value set for key: ${key}`);
+      } else {
+        console.log(`${key}=${value}`);
+      }
+    } else {
+      const config = this.configManager.getConfig();
+      console.log("Current configuration:", JSON.stringify(config, null, 2));
+    }
+  }
+  reset(key) {
+    const config = this.configManager.getConfig();
+    if (config[key] === void 0) {
+      console.log(`Key does not exist in the configuration: ${key}`);
+      return;
+    }
+    delete config[key];
+    this.configManager.writeConfig(key, void 0);
+    console.log(`Configuration key reset: ${key}`);
+  }
+};
+
+// src/commands/config/index.ts
+function initializeConfigCommands(program2) {
+  const configActions = new ConfigActions();
+  const configCommand = program2.command("config").description("Manage CLI configuration, including the default network");
+  configCommand.command("set").description("Set a configuration value").argument("<key=value>", "Configuration key-value pair to set").action((keyValue) => configActions.set(keyValue));
+  configCommand.command("get").description("Get the current configuration").argument("[key]", "Configuration key to retrieve").action((key) => configActions.get(key));
+  configCommand.command("reset").description("Reset a configuration value to its default").argument("<key>", "Configuration key to reset").action((key) => configActions.reset(key));
+  return program2;
+}
+
 // src/index.ts
 function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeConfigCommands(program);
   program.parse(process.argv);
 }
 initializeCLI();

package/docker-compose.yml

@@ -2,7 +2,7 @@ version: "3.8"
 
 services:
   frontend:
-    image: yeagerai/simulator-frontend:latest
+    image: yeagerai/simulator-frontend:${LOCALNETVERSION:-latest}
     ports:
       - "${FRONTEND_PORT:-8080}:8080"
     environment:
@@ -25,7 +25,7 @@ services:
 
 
   jsonrpc:
-    image: yeagerai/simulator-jsonrpc:latest
+    image: yeagerai/simulator-jsonrpc:${LOCALNETVERSION:-latest}
     environment:
       - FLASK_SERVER_PORT=${RPCPORT:-5000}
       - PYTHONUNBUFFERED=1
@@ -63,7 +63,7 @@ services:
       replicas: ${JSONRPC_REPLICAS:-1}
 
   webrequest:
-    image: yeagerai/simulator-webrequest:latest
+    image: yeagerai/simulator-webrequest:${LOCALNETVERSION:-latest}
     shm_size: 2gb
     environment:
       - FLASK_SERVER_PORT=${WEBREQUESTPORT:-5002}
@@ -131,7 +131,7 @@ services:
     #   - "./data/postgres:/var/lib/postgresql/data"
 
   database-migration:
-    image: yeagerai/simulator-database-migration:latest
+    image: yeagerai/simulator-database-migration:${LOCALNETVERSION:-latest}
     environment:
       - DB_URL=postgresql://${DBUSER:-postgres}:${DBPASSWORD:-postgres}@postgres/${DBNAME:-simulator_db}
       - WEBREQUESTPORT=${WEBREQUESTPORT:-5002}

package/package.json

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

package/src/commands/config/getSetReset.ts

@@ -0,0 +1,44 @@
+import { ConfigFileManager } from "../../lib/config/ConfigFileManager";
+
+export class ConfigActions {
+  private configManager: ConfigFileManager;
+
+  constructor() {
+    this.configManager = new ConfigFileManager();
+  }
+
+  set(keyValue: string): void {
+    const [key, value] = keyValue.split("=");
+    if (!key || value === undefined) {
+      console.error("Invalid format. Use key=value.");
+      process.exit(1);
+    }
+    this.configManager.writeConfig(key, value);
+    console.log(`Configuration updated: ${key}=${value}`);
+  }
+
+  get(key?: string): void {
+    if (key) {
+      const value = this.configManager.getConfigByKey(key);
+      if (value === null) {
+        console.log(`No value set for key: ${key}`);
+      } else {
+        console.log(`${key}=${value}`);
+      }
+    } else {
+      const config = this.configManager.getConfig();
+      console.log("Current configuration:", JSON.stringify(config, null, 2));
+    }
+  }
+
+  reset(key: string): void {
+    const config = this.configManager.getConfig();
+    if (config[key] === undefined) {
+      console.log(`Key does not exist in the configuration: ${key}`);
+      return;
+    }
+    delete config[key];
+    this.configManager.writeConfig(key, undefined);
+    console.log(`Configuration key reset: ${key}`);
+  }
+}

package/src/commands/config/index.ts

@@ -0,0 +1,30 @@
+import { Command } from "commander";
+import { ConfigActions } from "./getSetReset";
+
+export function initializeConfigCommands(program: Command) {
+  const configActions = new ConfigActions();
+
+  const configCommand = program
+    .command("config")
+    .description("Manage CLI configuration, including the default network");
+
+  configCommand
+    .command("set")
+    .description("Set a configuration value")
+    .argument("<key=value>", "Configuration key-value pair to set")
+    .action((keyValue: string) => configActions.set(keyValue));
+
+  configCommand
+    .command("get")
+    .description("Get the current configuration")
+    .argument("[key]", "Configuration key to retrieve")
+    .action((key?: string) => configActions.get(key));
+
+  configCommand
+    .command("reset")
+    .description("Reset a configuration value to its default")
+    .argument("<key>", "Configuration key to reset")
+    .action((key: string) => configActions.reset(key));
+
+  return program;
+}

package/src/commands/general/index.ts

@@ -11,6 +11,7 @@ export function initializeGeneralCommands(program: Command) {
     .option("--numValidators <numValidators>", "Number of validators", "5")
     .option("--headless", "Headless mode", false)
     .option("--reset-db", "Reset Database", false)
+    .option("--localnet-version <localnetVersion>", "Select a specific localnet version", 'latest')
     .action((options: InitActionOptions) => initAction(options, simulatorService));
 
   program

package/src/commands/general/init.ts

@@ -6,6 +6,7 @@ export interface InitActionOptions {
   numValidators: number;
   headless: boolean;
   resetDb: boolean;
+  localnetVersion: string;
 }
 
 function getRequirementsErrorMessage({docker}: Record<string, boolean>): string {
@@ -34,6 +35,11 @@ function getVersionErrorMessage({docker, node}: Record<string, string>): string
 export async function initAction(options: InitActionOptions, simulatorService: ISimulatorService) {
   simulatorService.setComposeOptions(options.headless);
 
+  let localnetVersion = options.localnetVersion;
+
+  if(localnetVersion !== 'latest'){
+    localnetVersion = simulatorService.normalizeLocalnetVersion(localnetVersion);
+  }
   await simulatorService.checkCliVersion();
 
   // Check if requirements are installed
@@ -139,6 +145,7 @@ export async function initAction(options: InitActionOptions, simulatorService: I
 
   console.log("Configuring GenLayer Simulator environment...");
   simulatorService.addConfigToEnvFile(aiProvidersEnvVars);
+  simulatorService.addConfigToEnvFile({LOCALNETVERSION: localnetVersion});
 
 
   // Run the GenLayer Simulator

package/src/index.ts

@@ -4,11 +4,13 @@ import {version} from "../package.json";
 import {CLI_DESCRIPTION} from "../src/lib/config/text";
 import { initializeGeneralCommands } from "../src/commands/general";
 import { initializeKeygenCommands } from "../src/commands/keygen";
+import { initializeConfigCommands } from "../src/commands/config";
 
 export function initializeCLI() {
   program.version(version).description(CLI_DESCRIPTION);
   initializeGeneralCommands(program);
   initializeKeygenCommands(program);
+  initializeConfigCommands(program);
   program.parse(process.argv);
 }
 

package/src/lib/interfaces/ISimulatorService.ts

@@ -18,6 +18,7 @@ export interface ISimulatorService {
   checkCliVersion(): Promise<void>;
   cleanDatabase(): Promise<boolean>;
   addConfigToEnvFile(newConfig: Record<string, string>): void;
+  normalizeLocalnetVersion(version: string): string;
 }
 
 

package/src/lib/services/simulator.ts

@@ -295,6 +295,23 @@ export class SimulatorService implements ISimulatorService {
     return true;
   }
 
+  public normalizeLocalnetVersion(version: string) {
+
+    if (!version.startsWith('v')) {
+      version = 'v' + version;
+    }
+
+    const versionRegex = /^v(\d+)\.(\d+)\.(\d+)(-.+)?$/;
+    const match = version.match(versionRegex);
+
+    if (!match) {
+      console.error('Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix');
+      process.exit(1);
+    }
+
+    return version
+  }
+
 }
 
 export default new SimulatorService();

package/tests/actions/create.test.ts

@@ -89,7 +89,7 @@ describe("KeypairCreator", () => {
 
   test("overwrites the file if overwrite is true", () => {
     const consoleLogSpy = vi.spyOn(console, "log");
-    vi.mocked(existsSync).mockReturnValue(true); // Simulate file exists
+    vi.mocked(existsSync).mockReturnValue(true);
     const options = { output: "keypair.json", overwrite: true };
 
     keypairCreator.createKeypairAction(options);

package/tests/actions/getSetReset.test.ts

@@ -0,0 +1,101 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+import { ConfigFileManager } from "../../src/lib/config/ConfigFileManager";
+
+vi.mock("../../src/lib/config/ConfigFileManager");
+
+describe("ConfigActions", () => {
+  let configActions: ConfigActions;
+
+  beforeEach(() => {
+    configActions = new ConfigActions();
+    vi.clearAllMocks();
+  });
+
+  new ConfigFileManager();
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("set method writes key-value pair to the configuration", () => {
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.set("defaultNetwork=testnet");
+
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", "testnet");
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration updated: defaultNetwork=testnet");
+  });
+
+  test("set method throws error for invalid format", () => {
+    const consoleErrorSpy = vi.spyOn(console, "error");
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    expect(() => configActions.set("invalidFormat")).toThrowError("process.exit");
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid format. Use key=value.");
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+  });
+
+  test("get method retrieves value for a specific key", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue("testnet");
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("defaultNetwork");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("defaultNetwork");
+    expect(consoleLogSpy).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("get method prints message when key has no value", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfigByKey).mockReturnValue(null);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get("nonexistentKey");
+
+    expect(configActions["configManager"].getConfigByKey).toHaveBeenCalledWith("nonexistentKey");
+    expect(consoleLogSpy).toHaveBeenCalledWith("No value set for key: nonexistentKey");
+  });
+
+  test("get method retrieves the entire configuration when no key is provided", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.get();
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Current configuration:", JSON.stringify(mockConfig, null, 2));
+  });
+
+  test("reset method removes key from configuration", () => {
+    const mockConfig = { defaultNetwork: "testnet" };
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("defaultNetwork");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).toHaveBeenCalledWith("defaultNetwork", undefined);
+    expect(consoleLogSpy).toHaveBeenCalledWith("Configuration key reset: defaultNetwork");
+  });
+
+  test("reset method prints message when key does not exist", () => {
+    const mockConfig = {};
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue(mockConfig);
+
+    const consoleLogSpy = vi.spyOn(console, "log");
+
+    configActions.reset("nonexistentKey");
+
+    expect(configActions["configManager"].getConfig).toHaveBeenCalledTimes(1);
+    expect(configActions["configManager"].writeConfig).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith("Key does not exist in the configuration: nonexistentKey");
+  });
+});

package/tests/actions/init.test.ts

@@ -14,7 +14,7 @@ vi.mock("dotenv");
 
 
 const tempDir = mkdtempSync(join(tmpdir(), "test-initAction-"));
-const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false };
+const defaultActionOptions = { numValidators: 5, branch: "main", location: tempDir, headless: false, resetDb: false, localnetVersion: 'latest' };
 
 describe("init action", () => {
   let error: ReturnType<any>;
@@ -201,7 +201,7 @@ describe("init action", () => {
     simServResetDockerContainers.mockResolvedValue(true);
     simServResetDockerImages.mockResolvedValue(true);
 
-    await initAction({...defaultActionOptions, headless: true, resetDb: true}, simulatorService);
+    await initAction({...defaultActionOptions, headless: true, resetDb: true, localnetVersion: "v1.0.0"}, simulatorService);
 
     expect(log).toHaveBeenCalledWith(
       `GenLayer simulator initialized successfully! `
@@ -441,4 +441,5 @@ describe("init action", () => {
 
     expect(error).toHaveBeenCalledWith(errorMsg);
   });
+
 });

package/tests/commands/config.test.ts

@@ -0,0 +1,54 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeConfigCommands } from "../../src/commands/config";
+import { ConfigActions } from "../../src/commands/config/getSetReset";
+
+vi.mock("../../src/commands/config/getSetReset");
+
+describe("config commands", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeConfigCommands(program);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("ConfigActions.set is called with the correct key-value pair", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.set).toHaveBeenCalledWith("defaultNetwork=testnet");
+  });
+
+  test("ConfigActions.get is called with a specific key", async () => {
+    program.parse(["node", "test", "config", "get", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions.get is called without a key", async () => {
+    program.parse(["node", "test", "config", "get"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.get).toHaveBeenCalledWith(undefined);
+  });
+
+  test("ConfigActions.reset is called with the correct key", async () => {
+    program.parse(["node", "test", "config", "reset", "defaultNetwork"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+    expect(ConfigActions.prototype.reset).toHaveBeenCalledWith("defaultNetwork");
+  });
+
+  test("ConfigActions is instantiated when the command is executed", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    expect(ConfigActions).toHaveBeenCalledTimes(1);
+  });
+
+  test("ConfigActions.set is called without throwing errors for valid input", async () => {
+    program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"]);
+    vi.mocked(ConfigActions.prototype.set).mockReturnValue();
+    expect(() => program.parse(["node", "test", "config", "set", "defaultNetwork=testnet"])).not.toThrow();
+  });
+});

package/tests/commands/init.test.ts

@@ -8,7 +8,8 @@ const openFrontendSpy = vi.spyOn(simulatorService, "openFrontend");
 const defaultOptions = {
   numValidators: "5",
   headless: false,
-  resetDb: false
+  resetDb: false,
+  localnetVersion: 'latest'
 }
 
 vi.mock("inquirer", () => ({
@@ -73,4 +74,11 @@ describe("init command", () => {
     expect(action).toHaveBeenCalledWith({...defaultOptions, headless: true});
     expect(openFrontendSpy).not.toHaveBeenCalled();
   });
+
+  test("option --localnet-version is accepted", async () => {
+    program.parse(["node", "test", "init", "--localnet-version", "v1.0.0"]);
+    expect(action).toHaveBeenCalledTimes(1);
+    expect(action).toHaveBeenCalledWith({...defaultOptions, localnetVersion: "v1.0.0"});
+    expect(openFrontendSpy).not.toHaveBeenCalled();
+  });
 });

package/tests/index.test.ts

@@ -17,6 +17,10 @@ vi.mock("../src/commands/keygen", () => ({
   initializeKeygenCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/config", () => ({
+  initializeConfigCommands: vi.fn(),
+}));
+
 
 describe("CLI", () => {
   it("should initialize CLI", () => {

package/tests/services/simulator.test.ts

@@ -505,3 +505,37 @@ describe("SimulatorService - Docker Tests", () => {
     consoleWarnSpy.mockRestore();
   });
 });
+
+describe('normalizeLocalnetVersion', () => {
+  test('should add "v" if not present', () => {
+    expect(simulatorService.normalizeLocalnetVersion("0.26.0")).toBe("v0.26.0");
+  });
+
+  test('should preserve "v" if already present', () => {
+    expect(simulatorService.normalizeLocalnetVersion("v0.26.0")).toBe("v0.26.0");
+  });
+
+  test('should retain suffixes like "-test000"', () => {
+    expect(simulatorService.normalizeLocalnetVersion("0.25.0-test000")).toBe("v0.25.0-test000");
+    expect(simulatorService.normalizeLocalnetVersion("v1.0.0-alpha")).toBe("v1.0.0-alpha");
+  });
+
+  test('should handle versions with numbers only', () => {
+    expect(simulatorService.normalizeLocalnetVersion("1.0.0")).toBe("v1.0.0");
+  });
+
+  test('should throw an error and exit for invalid versions', () => {
+    const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => { return undefined as never});
+    const mockConsoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    simulatorService.normalizeLocalnetVersion("invalid-version");
+
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      'Invalid version format. Expected format: v0.0.0 or v0.0.0-suffix'
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+
+    mockExit.mockRestore();
+    mockConsoleError.mockRestore();
+  });
+});