genlayer 0.12.1 → 0.12.2-beta.0

package/tests/actions/deploy.test.ts

@@ -3,16 +3,22 @@ import fs from "fs";
 import { createClient, createAccount } from "genlayer-js";
 import { DeployAction, DeployOptions } from "../../src/commands/contracts/deploy";
 import { getPrivateKey } from "../../src/lib/accounts/getPrivateKey";
+import { buildSync } from "esbuild";
+import { pathToFileURL } from "url";
 
 vi.mock("fs");
 vi.mock("genlayer-js");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 vi.mock("../../src/lib/accounts/getPrivateKey");
 
-describe("Deploy Action", () => {
+describe("DeployAction", () => {
   let deployer: DeployAction;
   const mockClient = {
     deployContract: vi.fn(),
-    waitForTransactionReceipt: vi.fn()
+    waitForTransactionReceipt: vi.fn(),
+    initializeConsensusSmartContract: vi.fn(),
   };
 
   const mockPrivateKey = "mocked_private_key";
@@ -23,6 +29,12 @@ describe("Deploy Action", () => {
     vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
     vi.mocked(getPrivateKey).mockReturnValue(mockPrivateKey);
     deployer = new DeployAction();
+
+    vi.spyOn(deployer as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "failSpinner").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "setSpinnerText").mockImplementation(() => {});
+    vi.spyOn(deployer as any, "log").mockImplementation(() => {});
   });
 
   afterEach(() => {
@@ -52,7 +64,6 @@ describe("Deploy Action", () => {
     expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
   });
 
-
   test("deploys contract with args", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
@@ -63,7 +74,9 @@ describe("Deploy Action", () => {
     vi.mocked(fs.existsSync).mockReturnValue(true);
     vi.mocked(fs.readFileSync).mockReturnValue(contractContent);
     vi.mocked(mockClient.deployContract).mockResolvedValue("mocked_tx_hash");
-    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({data: {contractAddress: '0xdasdsadasdasdada'}});
+    vi.mocked(mockClient.waitForTransactionReceipt).mockResolvedValue({
+      data: { contract_address: "0xdasdsadasdasdada" },
+    });
 
     await deployer.deploy(options);
 
@@ -73,31 +86,15 @@ describe("Deploy Action", () => {
       args: [1, 2, 3],
       leaderOnly: false,
     });
-    expect(mockClient.deployContract).toHaveResolvedWith("mocked_tx_hash");
-  });
-
-  test("throws error for both args and kwargs", async () => {
-    const options: DeployOptions = {
-      contract: "/mocked/contract/path",
-      args: [1, 2, 3],
-      kwargs: "key1=value1,key2=42",
-    };
-
-    await expect(deployer.deploy(options)).rejects.toThrowError(
-      "Invalid usage: Please specify either `args` or `kwargs`, but not both."
-    );
-
-    expect(fs.readFileSync).not.toHaveBeenCalled();
-    expect(mockClient.deployContract).not.toHaveBeenCalled();
+    expect(mockClient.deployContract).toHaveReturnedWith(Promise.resolve("mocked_tx_hash"));
   });
 
   test("throws error for missing contract", async () => {
-    const options: DeployOptions = {
-    };
+    const options: DeployOptions = {};
 
     await deployer.deploy(options);
 
-    expect(fs.readFileSync).not.toHaveBeenCalled();
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No contract specified for deployment.");
     expect(mockClient.deployContract).not.toHaveBeenCalled();
   });
 
@@ -114,15 +111,13 @@ describe("Deploy Action", () => {
       new Error("Mocked deployment error")
     );
 
-    await expect(deployer.deploy(options)).rejects.toThrowError(
-      "Contract deployment failed."
-    );
+    await deployer.deploy(options);
 
-    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Error deploying contract", expect.any(Error));
     expect(mockClient.deployContract).toHaveBeenCalled();
   });
 
-  test("throws error if contract code is empty", async () => {
+  test("handles empty contract code", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
     };
@@ -132,8 +127,183 @@ describe("Deploy Action", () => {
 
     await deployer.deploy(options);
 
-    expect(fs.existsSync).toHaveBeenCalledWith(options.contract);
-    expect(fs.readFileSync).toHaveBeenCalledWith(options.contract, "utf-8");
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
     expect(mockClient.deployContract).not.toHaveBeenCalled();
   });
+
+  test("deployScripts executes scripts in order", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "1_first.ts",
+      "2_second.js",
+      "10_last.ts",
+    ] as any);
+
+    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+
+    await deployer.deployScripts();
+
+    expect(deployer["setSpinnerText"]).toHaveBeenCalledWith("Found 3 deploy scripts. Executing...");
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/1_first.ts/));
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringMatching(/2_second.js/));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringMatching(/10_last.ts/));
+  });
+
+  test("executeTsScript transpiles and executes TypeScript", async () => {
+    const filePath = "/mocked/script.ts";
+    const outFile = "/mocked/script.compiled.js";
+
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+    vi.mocked(buildSync).mockImplementation((() => {}) as any);
+
+    await deployer["executeTsScript"](filePath);
+
+    expect(deployer["startSpinner"]).toHaveBeenCalledWith(`Transpiling TypeScript file: ${filePath}`);
+    expect(buildSync).toHaveBeenCalledWith({
+      entryPoints: [filePath],
+      outfile: outFile,
+      bundle: false,
+      platform: "node",
+      format: "esm",
+      target: "es2020",
+      sourcemap: false,
+    });
+
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(filePath, outFile);
+    expect(fs.unlinkSync).toHaveBeenCalledWith(outFile);
+  });
+
+  test("deployScripts fails when deploy folder is missing", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy folder found.");
+  });
+
+  test("deployScripts sorts and executes scripts correctly", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "10_last.ts",
+      "2_second.js",
+      "1_first.ts"
+    ] as any);
+
+    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+
+    await deployer.deployScripts();
+
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("1_first.ts"));
+    expect(deployer["executeJsScript"]).toHaveBeenCalledWith(expect.stringContaining("2_second.js"));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("10_last.ts"));
+  });
+
+  test("deployScripts fails when no scripts are found", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([]);
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("No deploy scripts found.");
+  });
+
+  test("deployScripts handles script execution errors", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue(["1_failing.ts"] as any);
+    vi.spyOn(deployer as any, "executeTsScript").mockRejectedValue(new Error("Script error"));
+
+    await deployer.deployScripts();
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining("Error executing script:"),
+      expect.any(Error)
+    );
+  });
+
+  test("executeJsScript fails gracefully", async () => {
+    const filePath = "/mocked/script.js";
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining("Error executing:"),
+      expect.any(Error)
+    );
+  });
+
+  test("deploy fails when contract code is empty", async () => {
+    const options: DeployOptions = { contract: "/mocked/contract/path" };
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue("");
+
+    await deployer.deploy(options);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith("Contract code is empty.");
+  });
+
+  test("deployScripts correctly sorts mixed numbered and non-numbered scripts", async () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readdirSync).mockReturnValue([
+      "script.ts",
+      "2alpha_script.ts",
+      "3alpha_script.ts",
+      "blpha_script.ts",
+      "clpha_script.ts"
+    ] as any);
+
+    vi.spyOn(deployer as any, "executeTsScript").mockResolvedValue(undefined);
+    vi.spyOn(deployer as any, "executeJsScript").mockResolvedValue(undefined);
+
+    await deployer.deployScripts();
+
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("script.ts"));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("2alpha_script.ts"));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("3alpha_script.ts"));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("blpha_script.ts"));
+    expect(deployer["executeTsScript"]).toHaveBeenCalledWith(expect.stringContaining("clpha_script.ts"));
+  });
+
+  test("executeJsScript fails if module has no default export", async () => {
+    const filePath = "/mocked/script.js";
+
+    vi.doMock(pathToFileURL(filePath).href, () => ({ default: "Not a function" }));
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      expect.stringContaining("No \"default\" function found in:"),
+    );
+  });
+
+  test("executeJsScript successfully executes a script", async () => {
+    const filePath = "/mocked/script.js";
+    const mockFn = vi.fn(); // This mock function simulates the script execution
+
+    vi.doMock(pathToFileURL(filePath).href, () => ({ default: mockFn }));
+
+    await deployer["executeJsScript"](filePath);
+
+    expect(mockFn).toHaveBeenCalledWith(deployer["genlayerClient"]);
+
+    expect(deployer["succeedSpinner"]).toHaveBeenCalledWith(`Successfully executed: ${filePath}`);
+  });
+
+  test("executeTsScript fails when buildSync throws an error", async () => {
+    const filePath = "/mocked/script.ts";
+    const error = new Error("Build failed");
+
+    vi.mocked(buildSync).mockImplementation(() => {
+      throw error; // Simulate an error during transpilation
+    });
+
+    await deployer["executeTsScript"](filePath);
+
+    expect(deployer["failSpinner"]).toHaveBeenCalledWith(
+      `Error executing: ${filePath}`,
+      error
+    );
+  });
 });

package/tests/actions/getSetReset.test.ts

@@ -10,92 +10,79 @@ describe("ConfigActions", () => {
   beforeEach(() => {
     configActions = new ConfigActions();
     vi.clearAllMocks();
-  });
 
-  new ConfigFileManager();
+    vi.spyOn(configActions as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(configActions as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(configActions as any, "failSpinner").mockImplementation(() => {});
+  });
 
   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");
+    expect(configActions["writeConfig"]).toHaveBeenCalledWith("defaultNetwork", "testnet");
+    expect(configActions["startSpinner"]).toHaveBeenCalledWith("Updating configuration: defaultNetwork");
+    expect(configActions["succeedSpinner"]).toHaveBeenCalledWith("Configuration successfully updated");
   });
 
-  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");
-    });
+  test("set method fails for invalid format", () => {
+    configActions.set("invalidFormat");
 
-    expect(() => configActions.set("invalidFormat")).toThrowError("process.exit");
-
-    expect(consoleErrorSpy).toHaveBeenCalledWith("Invalid format. Use key=value.");
-    expect(processExitSpy).toHaveBeenCalledWith(1);
+    expect(configActions["failSpinner"]).toHaveBeenCalledWith("Invalid format. Use 'key=value'.");
+    expect(configActions["writeConfig"]).not.toHaveBeenCalled();
   });
 
   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");
+    expect(configActions["getConfigByKey"]).toHaveBeenCalledWith("defaultNetwork");
+    expect(configActions["startSpinner"]).toHaveBeenCalledWith("Retrieving value for: defaultNetwork");
+    expect(configActions["succeedSpinner"]).toHaveBeenCalledWith("Configuration successfully retrieved", "defaultNetwork=testnet");
   });
 
-  test("get method prints message when key has no value", () => {
+  test("get method prints failure message when key does not exist", () => {
     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");
+    expect(configActions["getConfigByKey"]).toHaveBeenCalledWith("nonexistentKey");
+    expect(configActions["failSpinner"]).toHaveBeenCalledWith("No configuration found for '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));
+    expect(configActions["getConfig"]).toHaveBeenCalled();
+    expect(configActions["startSpinner"]).toHaveBeenCalledWith("Retrieving all configurations");
+    expect(configActions["succeedSpinner"]).toHaveBeenCalledWith("All configurations successfully retrieved", 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");
+    expect(configActions["getConfig"]).toHaveBeenCalled();
+    expect(configActions["startSpinner"]).toHaveBeenCalledWith("Resetting configuration: defaultNetwork");
+    expect(configActions["writeConfig"]).toHaveBeenCalledWith("defaultNetwork", undefined);
+    expect(configActions["succeedSpinner"]).toHaveBeenCalledWith("Configuration successfully reset");
   });
 
-  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");
+  test("reset method prints failure message when key does not exist", () => {
+    vi.mocked(ConfigFileManager.prototype.getConfig).mockReturnValue({});
 
     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");
+    expect(configActions["getConfig"]).toHaveBeenCalled();
+    expect(configActions["failSpinner"]).toHaveBeenCalledWith("Configuration key 'nonexistentKey' does not exist.");
   });
-});
+});