@tkeron/commands 0.3.1 → 0.4.0

package/tests/getCommandsFuncs.test.ts

@@ -0,0 +1,492 @@
+import { beforeEach, describe, expect, it, mock, spyOn } from "bun:test";
+import type {
+  CommandFactory,
+  Commands,
+  CommandsCollection,
+} from "../src/types.js";
+import {
+  getAddAlias,
+  getAddDescription,
+  getAddFooterText,
+  getAddHeaderText,
+  getAddOption,
+  getAddPositionedArgument,
+  getCommands,
+  getGetHelpLine,
+  getSetCallback,
+  initCommands,
+  initHelpAndVersion,
+} from "../src/getCommandsFuncs.js";
+
+describe("main", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("getCommands", () => {
+    const commands = getCommands();
+    expect(commands).toBeTruthy();
+  });
+  it("initHelpAndVersion", () => {
+    expect(commandsCollection).not.toHaveProperty("help");
+    expect(commandsCollection).not.toHaveProperty("version");
+    const { helpCallback, versionCallback } = initHelpAndVersion(
+      commands,
+      commandsCollection,
+    );
+    expect(commandsCollection).toHaveProperty("help");
+    expect(commandsCollection).toHaveProperty("version");
+
+    const logMock = spyOn(console, "log").mockImplementation(() => {});
+    expect(helpCallback).not.toThrow();
+    expect(versionCallback).not.toThrow();
+    logMock.mockRestore();
+  });
+  it("getAddOption", () => {
+    commands.addCommand("test");
+    const addOption = getAddOption(commandFactory, commandsCollection);
+    addOption("op001");
+    const { test } = commandsCollection;
+    expect(test.options).toContain("op001");
+  });
+  it("getAddPositionedArgument", () => {
+    commands.addCommand("test");
+    const addPositionedArgument = getAddPositionedArgument(
+      commandFactory,
+      commandsCollection,
+    );
+
+    addPositionedArgument("pos001");
+    const { test } = commandsCollection;
+
+    expect(test.positionedArguments).toContain("pos001");
+  });
+  it("getAddHeaderText", () => {
+    const addHeaderText = getAddHeaderText(commands);
+    const txt = "test header text...";
+    addHeaderText(txt);
+    expect(commands.headerText).toBe(txt);
+  });
+  it("getAddFooterText", () => {
+    const addFooterText = getAddFooterText(commands);
+    const txt = "test footer text...";
+    addFooterText(txt);
+    expect(commands.footerText).toBe(txt);
+  });
+  it("getGetHelpLine", () => {
+    commands.addCommand("test");
+    const { test } = commandsCollection;
+    const getHelpLine = getGetHelpLine(test);
+    const hl50 = getHelpLine();
+    expect(hl50).toBe("test  ............................................  \n");
+  });
+  it("should set commandFactory.commands when falsy", () => {
+    commandFactory.commands = <() => Commands>(<unknown>undefined);
+    initCommands(commandsCollection, commands, commandFactory);
+    expect(commandFactory.commands).toBeTruthy();
+    expect(commandFactory.commands).not.toThrow();
+  });
+});
+
+describe("getAddAlias", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("should add alias to command aliases array", () => {
+    commands.addCommand("test");
+    const addAlias = getAddAlias(commandFactory, commandsCollection);
+    addAlias("t");
+    expect(commandsCollection.test.aliases).toContain("t");
+  });
+
+  it("should register alias as key in commandsCollection", () => {
+    commands.addCommand("test");
+    const addAlias = getAddAlias(commandFactory, commandsCollection);
+    addAlias("t");
+    expect(commandsCollection.t).toBe(commandsCollection.test);
+  });
+
+  it("should support multiple aliases", () => {
+    commands.addCommand("test");
+    const addAlias = getAddAlias(commandFactory, commandsCollection);
+    addAlias("t");
+    addAlias("--test");
+    expect(commandsCollection.test.aliases).toEqual(["t", "--test"]);
+    expect(commandsCollection.t).toBe(commandsCollection.test);
+    expect(commandsCollection["--test"]).toBe(commandsCollection.test);
+  });
+
+  it("should return commandFactory for chaining", () => {
+    commands.addCommand("test");
+    const addAlias = getAddAlias(commandFactory, commandsCollection);
+    const result = addAlias("t");
+    expect(result).toBe(commandFactory);
+  });
+});
+
+describe("getAddDescription", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("should set description on command", () => {
+    commands.addCommand("test");
+    const addDescription = getAddDescription(
+      commandFactory,
+      commandsCollection,
+    );
+    addDescription("A test command");
+    expect(commandsCollection.test.description).toBe("A test command");
+  });
+
+  it("should return commandFactory for chaining", () => {
+    commands.addCommand("test");
+    const addDescription = getAddDescription(
+      commandFactory,
+      commandsCollection,
+    );
+    const result = addDescription("desc");
+    expect(result).toBe(commandFactory);
+  });
+});
+
+describe("getSetCallback", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("should set callback on command", () => {
+    commands.addCommand("test");
+    const setCallback = getSetCallback(commandFactory, commandsCollection);
+    const cb = () => {};
+    setCallback(cb);
+    expect(commandsCollection.test.callback).toBe(cb);
+  });
+
+  it("should return commandFactory for chaining", () => {
+    commands.addCommand("test");
+    const setCallback = getSetCallback(commandFactory, commandsCollection);
+    const result = setCallback(() => {});
+    expect(result).toBe(commandFactory);
+  });
+});
+
+describe("getAddPositionedArgument deduplication", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+  let commandFactory: CommandFactory;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commandFactory = <CommandFactory>(<unknown>{
+      commands: undefined,
+      name: undefined,
+      addAlias: undefined,
+      addOption: undefined,
+      addPositionedArgument: undefined,
+      addDescription: undefined,
+      setCallback: undefined,
+    });
+    commands = initCommands(commandsCollection, undefined, commandFactory);
+  });
+
+  it("should not add duplicate positioned arguments", () => {
+    commands.addCommand("test");
+    const addArg = getAddPositionedArgument(commandFactory, commandsCollection);
+    addArg("pos001");
+    addArg("pos001");
+    expect(commandsCollection.test.positionedArguments).toEqual(["pos001"]);
+  });
+
+  it("should allow different positioned arguments", () => {
+    commands.addCommand("test");
+    const addArg = getAddPositionedArgument(commandFactory, commandsCollection);
+    addArg("input");
+    addArg("output");
+    expect(commandsCollection.test.positionedArguments).toEqual([
+      "input",
+      "output",
+    ]);
+  });
+});
+
+describe("getCommands extended", () => {
+  it("should use custom programName and version", () => {
+    const commands = getCommands("myapp", "1.2.3");
+    expect(commands.programName).toBe("myapp");
+    expect(commands.version).toBe("1.2.3");
+  });
+
+  it("should initialize with empty header and footer", () => {
+    const commands = getCommands();
+    expect(commands.headerText).toBe("");
+    expect(commands.footerText).toBe("");
+  });
+
+  it("should register help command via start", () => {
+    const logMock = spyOn(console, "log").mockImplementation(() => {});
+    const commands = getCommands();
+    commands.start(["node", "app", "help"]);
+    expect(logMock).toBeCalledTimes(1);
+    logMock.mockRestore();
+  });
+
+  it("should register version command via start", () => {
+    const logMock = spyOn(console, "log").mockImplementation(() => {});
+    const commands = getCommands("testapp", "2.0.0");
+    commands.start(["node", "app", "version"]);
+    expect(logMock).toBeCalledTimes(1);
+    logMock.mockRestore();
+  });
+});
+
+describe("chaining integration", () => {
+  it("should support full command building chain", () => {
+    const logMock = spyOn(console, "log").mockImplementation(() => {});
+    const cb = mock();
+    const commands = getCommands("myapp", "1.0.0");
+    commands
+      .addCommand("build")
+      .addAlias("b")
+      .addOption("output", "./dist")
+      .addPositionedArgument("source")
+      .addDescription("Build the project")
+      .setCallback(cb);
+
+    commands.start(["node", "app", "build", "src", "output=./dist"]);
+    expect(cb).toBeCalledTimes(1);
+    expect(cb).toBeCalledWith({ source: "src", output: "./dist" });
+    logMock.mockRestore();
+  });
+
+  it("should support alias execution", () => {
+    const logMock = spyOn(console, "log").mockImplementation(() => {});
+    const cb = mock();
+    const commands = getCommands("myapp", "1.0.0");
+    commands
+      .addCommand("build")
+      .addAlias("b")
+      .addDescription("Build the project")
+      .setCallback(cb);
+
+    commands.start(["node", "app", "b"]);
+    expect(cb).toBeCalledTimes(1);
+    logMock.mockRestore();
+  });
+
+  it("should support header and footer text chaining", () => {
+    const commands = getCommands("myapp", "1.0.0");
+    const result = commands.addHeaderText("Header").addFooterText("Footer");
+    expect(result.headerText).toBe("Header");
+    expect(result.footerText).toBe("Footer");
+  });
+
+  it("should navigate back to commands from commandFactory", () => {
+    const commands = getCommands("myapp", "1.0.0");
+    const returned = commands
+      .addCommand("test")
+      .addDescription("test")
+      .setCallback(() => {})
+      .commands();
+    expect(returned).toBe(commands);
+  });
+});
+
+describe("addOption with OptionDefinition", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commands = initCommands(commandsCollection);
+  });
+
+  it("should accept string (legacy API)", () => {
+    commands.addCommand("test").addOption("output", "./dist");
+    expect(commandsCollection.test.options).toContain("output");
+    expect(commandsCollection.test.optionsExamples).toContain("./dist");
+  });
+
+  it("should accept OptionDefinition object", () => {
+    commands.addCommand("test").addOption({
+      name: "output",
+      shortFlag: "o",
+      type: "string",
+      description: "Output directory",
+      default: "./dist",
+    });
+    expect(commandsCollection.test.optionDefinitions).toHaveLength(1);
+    expect(commandsCollection.test.optionDefinitions[0].name).toBe("output");
+    expect(commandsCollection.test.optionDefinitions[0].shortFlag).toBe("o");
+  });
+
+  it("should register option in optionDefinitions array", () => {
+    commands.addCommand("test").addOption({
+      name: "verbose",
+      type: "boolean",
+      description: "Verbose",
+    });
+    expect(commandsCollection.test.optionDefinitions).toHaveLength(1);
+  });
+
+  it("should support chaining with OptionDefinition", () => {
+    const result = commands
+      .addCommand("test")
+      .addOption({
+        name: "output",
+        type: "string",
+        description: "Output",
+      })
+      .addOption({
+        name: "verbose",
+        type: "boolean",
+        description: "Verbose",
+      });
+    expect(commandsCollection.test.optionDefinitions).toHaveLength(2);
+    expect(result.commands).toBeTruthy();
+  });
+});
+
+describe("addFlag helper", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commands = initCommands(commandsCollection);
+  });
+
+  it("should add boolean flag", () => {
+    commands.addCommand("test").addFlag("verbose", "v", "Enable verbose");
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.name).toBe("verbose");
+    expect(def.type).toBe("boolean");
+    expect(def.shortFlag).toBe("v");
+    expect(def.description).toBe("Enable verbose");
+  });
+
+  it("should add flag without short flag", () => {
+    commands.addCommand("test").addFlag("verbose", undefined, "Enable verbose");
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.name).toBe("verbose");
+    expect(def.shortFlag).toBeUndefined();
+  });
+
+  it("should return commandFactory for chaining", () => {
+    const result = commands.addCommand("test").addFlag("verbose");
+    expect(result.commands).toBeTruthy();
+  });
+});
+
+describe("addStringOption helper", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commands = initCommands(commandsCollection);
+  });
+
+  it("should add string option", () => {
+    commands
+      .addCommand("test")
+      .addStringOption("output", "o", "Output directory");
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.name).toBe("output");
+    expect(def.type).toBe("string");
+    expect(def.shortFlag).toBe("o");
+  });
+
+  it("should support config parameter", () => {
+    commands.addCommand("test").addStringOption("output", "o", "Output", {
+      default: "./dist",
+      required: true,
+    });
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.default).toBe("./dist");
+    expect(def.required).toBe(true);
+  });
+});
+
+describe("addNumberOption helper", () => {
+  let commandsCollection: CommandsCollection;
+  let commands: Commands;
+
+  beforeEach(() => {
+    commandsCollection = {};
+    commands = initCommands(commandsCollection);
+  });
+
+  it("should add number option", () => {
+    commands.addCommand("test").addNumberOption("port", "p", "Port number");
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.name).toBe("port");
+    expect(def.type).toBe("number");
+  });
+
+  it("should support config parameter", () => {
+    commands.addCommand("test").addNumberOption("port", "p", "Port", {
+      default: 3000,
+      required: false,
+    });
+    const def = commandsCollection.test.optionDefinitions[0];
+    expect(def.default).toBe(3000);
+  });
+});