genlayer 0.12.4 → 0.13.0

package/tests/actions/create.test.ts

@@ -20,10 +20,15 @@ describe("KeypairCreator", () => {
     address: "0xMockedAddress",
     privateKey: "0xMockedPrivateKey",
   };
-  keypairCreator = new KeypairCreator();
+
+  const mockKeypairManager = {
+    createKeypair: vi.fn(),
+  };
 
   beforeEach(() => {
     vi.clearAllMocks();
+    keypairCreator = new KeypairCreator();
+    (keypairCreator as any).keypairManager = mockKeypairManager;
     vi.spyOn(keypairCreator as any, "startSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "succeedSpinner").mockImplementation(() => {});
     vi.spyOn(keypairCreator as any, "failSpinner").mockImplementation(() => {});
@@ -43,86 +48,20 @@ describe("KeypairCreator", () => {
     keypairCreator.createKeypairAction(options);
 
     expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
-    expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
-    expect(keypairCreator["getFilePath"]).toHaveBeenCalledWith("keypair.json");
-
-
-    expect(writeFileSync).toHaveBeenCalledWith(
-      "/mocked/path/keypair.json",
-      JSON.stringify(
-        {
-          address: mockWallet.address,
-          privateKey: mockWallet.privateKey,
-        },
-        null,
-        2
-      )
-    );
-
-    expect(keypairCreator["writeConfig"]).toHaveBeenCalledWith(
-      "keyPairPath",
-      "/mocked/path/keypair.json"
-    );
-
+    expect(mockKeypairManager.createKeypair).toHaveBeenCalledWith(options.output, options.overwrite);
     expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
-      "Keypair successfully created and saved to: /mocked/path/keypair.json"
-    );
-  });
-
-  test("skips creation if file exists and overwrite is false", () => {
-    vi.mocked(existsSync).mockReturnValue(true);
-    const options = { output: "keypair.json", overwrite: false };
-
-    keypairCreator.createKeypairAction(options);
-
-    expect(ethers.Wallet.createRandom).not.toHaveBeenCalled();
-    expect(writeFileSync).not.toHaveBeenCalled();
-    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith(
-      "The file at /mocked/path/keypair.json already exists. Use the '--overwrite' option to replace it."
-    );
-  });
-
-  test("overwrites the file if overwrite is true", () => {
-    vi.mocked(existsSync).mockReturnValue(true);
-    const options = { output: "keypair.json", overwrite: true };
-
-    keypairCreator.createKeypairAction(options);
-
-    expect(keypairCreator["startSpinner"]).toHaveBeenCalledWith("Creating keypair...");
-    expect(ethers.Wallet.createRandom).toHaveBeenCalledTimes(1);
-    expect(keypairCreator["getFilePath"]).toHaveBeenCalledWith("keypair.json");
-
-    expect(writeFileSync).toHaveBeenCalledWith(
-      "/mocked/path/keypair.json",
-      JSON.stringify(
-        {
-          address: mockWallet.address,
-          privateKey: mockWallet.privateKey,
-        },
-        null,
-        2
-      )
-    );
-
-    expect(keypairCreator["writeConfig"]).toHaveBeenCalledWith(
-      "keyPairPath",
-      "/mocked/path/keypair.json"
-    );
-
-    expect(keypairCreator["succeedSpinner"]).toHaveBeenCalledWith(
-      "Keypair successfully created and saved to: /mocked/path/keypair.json"
+      "Keypair successfully created and saved to: keypair.json"
     );
   });
 
   test("handles errors during keypair creation", () => {
-    const mockError = new Error("Mocked write error");
-
-    vi.mocked(writeFileSync).mockImplementation(() => {
+    const mockError = new Error("Mocked creation error");
+    mockKeypairManager.createKeypair.mockImplementation(() => {
       throw mockError;
     });
 
     keypairCreator.createKeypairAction({ output: "keypair.json", overwrite: true });
 
-    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keypair:", mockError);
+    expect(keypairCreator["failSpinner"]).toHaveBeenCalledWith("Failed to generate keypair", mockError);
   });
 });

package/tests/actions/deploy.test.ts

@@ -2,17 +2,21 @@ import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
 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("../../src/lib/accounts/getPrivateKey");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 
-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";
@@ -21,8 +25,14 @@ describe("Deploy Action", () => {
     vi.clearAllMocks();
     vi.mocked(createClient).mockReturnValue(mockClient as any);
     vi.mocked(createAccount).mockReturnValue({ privateKey: mockPrivateKey } as any);
-    vi.mocked(getPrivateKey).mockReturnValue(mockPrivateKey);
     deployer = new DeployAction();
+    vi.spyOn(deployer as any, "getPrivateKey").mockResolvedValue(mockPrivateKey);
+
+    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 +62,6 @@ describe("Deploy Action", () => {
     expect(fs.existsSync).toHaveBeenCalledWith(contractPath);
   });
 
-
   test("deploys contract with args", async () => {
     const options: DeployOptions = {
       contract: "/mocked/contract/path",
@@ -63,7 +72,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 +84,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 +109,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 +125,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(mockClient);
+
+    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/new.test.ts

@@ -0,0 +1,80 @@
+import { describe, test, vi, beforeEach, afterEach, expect } from "vitest";
+import fs from "fs-extra";
+import path from "path";
+import { NewAction } from "../../src/commands/scaffold/new";
+
+vi.mock("fs-extra");
+
+describe("NewAction", () => {
+  let newAction: NewAction;
+  let mockExistsSync: any;
+  let mockCopySync: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    newAction = new NewAction();
+
+    mockExistsSync = vi.mocked(fs.existsSync);
+    mockCopySync = vi.mocked(fs.copySync);
+
+    vi.spyOn(newAction as any, "startSpinner").mockImplementation(() => {});
+    vi.spyOn(newAction as any, "succeedSpinner").mockImplementation(() => {});
+    vi.spyOn(newAction as any, "failSpinner").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("should successfully create a new project", async () => {
+    mockExistsSync.mockReturnValue(false);
+    mockCopySync.mockImplementation(() => {});
+
+    await newAction.createProject("myProject", { path: ".", overwrite: false });
+
+    expect(newAction["startSpinner"]).toHaveBeenCalledWith("Creating new GenLayer project: myProject");
+    expect(mockCopySync).toHaveBeenCalledWith(expect.any(String), path.resolve(".", "myProject"));
+    expect(newAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Project "myProject" created successfully at ${path.resolve(".", "myProject")}`
+    );
+  });
+
+  test("should fail if project directory exists and overwrite is not set", async () => {
+    mockExistsSync.mockReturnValue(true);
+
+    await newAction.createProject("existingProject", { path: ".", overwrite: false });
+
+    expect(newAction["failSpinner"]).toHaveBeenCalledWith(
+      `Project directory "${path.resolve(".", "existingProject")}" already exists. Use --overwrite to replace it.`
+    );
+    expect(mockCopySync).not.toHaveBeenCalled();
+  });
+
+  test("should overwrite existing project if overwrite is set", async () => {
+    mockExistsSync.mockReturnValue(true);
+    mockCopySync.mockImplementation(() => {});
+
+    await newAction.createProject("overwriteProject", { path: ".", overwrite: true });
+
+    expect(newAction["startSpinner"]).toHaveBeenCalledWith("Creating new GenLayer project: overwriteProject");
+    expect(mockCopySync).toHaveBeenCalledWith(expect.any(String), path.resolve(".", "overwriteProject"));
+    expect(newAction["succeedSpinner"]).toHaveBeenCalledWith(
+      `Project "overwriteProject" created successfully at ${path.resolve(".", "overwriteProject")}`
+    );
+  });
+
+  test("should fail if an error occurs while copying files", async () => {
+    mockExistsSync.mockReturnValue(false);
+    const error = new Error("Mocked file system error");
+    mockCopySync.mockImplementation(() => {
+      throw error;
+    });
+
+    await newAction.createProject("errorProject", { path: ".", overwrite: false });
+
+    expect(newAction["failSpinner"]).toHaveBeenCalledWith(
+      "Error creating project \"errorProject\"",
+      error
+    );
+  });
+});

package/tests/commands/call.test.ts

@@ -4,6 +4,9 @@ import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
 import { initializeContractsCommands } from "../../src/commands/contracts";
 
 vi.mock("../../src/commands/contracts/call");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 
 describe("call command", () => {
   let program: Command;
@@ -39,12 +42,14 @@ describe("call command", () => {
       "1",
       "2",
       "Hello",
+      "false",
+      "true"
     ]);
     expect(CallAction).toHaveBeenCalledTimes(1);
     expect(CallAction.prototype.call).toHaveBeenCalledWith({
       contractAddress: "0xMockedContract",
       method: "updateData",
-      args: ["1", "2", "Hello"]
+      args: [1, 2, "Hello", false, true]
     });
   });
 

package/tests/commands/deploy.test.ts

@@ -4,6 +4,9 @@ import { initializeContractsCommands } from "../../src/commands/contracts";
 import { DeployAction } from "../../src/commands/contracts/deploy";
 
 vi.mock("../../src/commands/contracts/deploy");
+vi.mock("esbuild", () => ({
+  buildSync: vi.fn(),
+}));
 
 describe("deploy command", () => {
   let program: Command;
@@ -42,7 +45,7 @@ describe("deploy command", () => {
     expect(DeployAction).toHaveBeenCalledTimes(1);
     expect(DeployAction.prototype.deploy).toHaveBeenCalledWith({
       contract: "./path/to/contract",
-      args: ["1", "2", "3"]
+      args: [1, 2, 3]
     });
   });
 
@@ -66,4 +69,12 @@ describe("deploy command", () => {
       program.parse(["node", "test", "deploy", "--contract", "./path/to/contract"])
     ).not.toThrow();
   });
+
+  test("DeployAction.deployScripts is called without throwing errors", async () => {
+    program.parse(["node", "test", "deploy"]);
+    vi.mocked(DeployAction.prototype.deployScripts).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "deploy"])
+    ).not.toThrow();
+  });
 });

package/tests/commands/new.test.ts

@@ -0,0 +1,68 @@
+import { Command } from "commander";
+import { vi, describe, beforeEach, afterEach, test, expect } from "vitest";
+import { initializeScaffoldCommands } from "../../src/commands/scaffold";
+import { NewAction } from "../../src/commands/scaffold/new";
+
+vi.mock("../../src/commands/scaffold/new");
+
+describe("new command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    program = new Command();
+    initializeScaffoldCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test("NewAction.createProject is called with default options", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: ".",
+      overwrite: false,
+    });
+  });
+
+  test("NewAction.createProject is called with custom path", async () => {
+    program.parse(["node", "test", "new", "myProject", "--path", "./customDir"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: "./customDir",
+      overwrite: false,
+    });
+  });
+
+  test("NewAction.createProject is called with overwrite flag", async () => {
+    program.parse(["node", "test", "new", "myProject", "--overwrite"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+    expect(NewAction.prototype.createProject).toHaveBeenCalledWith("myProject", {
+      path: ".",
+      overwrite: true,
+    });
+  });
+
+  test("NewAction is instantiated when the new command is executed", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    expect(NewAction).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws error for unrecognized options", async () => {
+    const newCommand = program.commands.find((cmd) => cmd.name() === "new");
+    newCommand?.exitOverride();
+    expect(() => program.parse(["node", "test", "new", "myProject", "--unknown"])).toThrowError(
+      "error: unknown option '--unknown'"
+    );
+  });
+
+  test("NewAction.createProject is called without throwing errors for valid options", async () => {
+    program.parse(["node", "test", "new", "myProject"]);
+    vi.mocked(NewAction.prototype.createProject).mockResolvedValueOnce(undefined);
+    expect(() =>
+      program.parse(["node", "test", "new", "myProject"])
+    ).not.toThrow();
+  });
+});

package/tests/index.test.ts

@@ -33,6 +33,10 @@ vi.mock("../src/commands/update", () => ({
   initializeUpdateCommands: vi.fn(),
 }));
 
+vi.mock("../src/commands/scaffold", () => ({
+  initializeScaffoldCommands: vi.fn(),
+}));
+
 
 describe("CLI", () => {
   it("should initialize CLI", () => {