@flowscripter/dynamic-cli-framework 1.1.5 → 1.2.0

package/tests/cli/BaseCLI.test.ts

@@ -23,24 +23,31 @@ import type Context from "../../src/api/Context.ts";
 import type CLIConfig from "../../src/api/CLIConfig.ts";
 import StreamString from "../fixtures/StreamString.ts";
 import { expectStringEquals, expectStringIncludes } from "../fixtures/util.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
+import type KeyReader from "../../src/terminal/KeyReader.ts";
+
+const mockKeyReader: KeyReader = {
+  enableRawMode() {},
+  disableRawMode() {},
+  readKey: () => Promise.resolve({}),
+};
 
 describe("BaseCLI tests", () => {
   test("BaseCLI no command specified works", async () => {
     const config = getCLIConfig();
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
-    const terminal = new TtyTerminal(dummyStdout.writeStream);
     const baseCLI = new BaseCLI(
       config,
       dummyStdout.writableStream,
       dummyStderr.writableStream,
       false,
       false,
-      terminal,
+      new TtyTerminal(dummyStdout.writeStream),
+      new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
+      mockKeyReader,
     );
 
     baseCLI.addCommand(getSubCommandWithOptionAndPositional());
@@ -54,16 +61,16 @@ describe("BaseCLI tests", () => {
     const config = getCLIConfig();
     const dummyStdout = new StreamString();
     const dummyStderr = new StreamString();
-    const terminal = new TtyTerminal(dummyStderr.writeStream);
     const baseCLI = new BaseCLI(
       config,
       dummyStdout.writableStream,
       dummyStderr.writableStream,
       false,
       false,
-      terminal,
+      new TtyTerminal(dummyStdout.writeStream),
+      new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
+      mockKeyReader,
     );
 
     let modifierHasRun = false;
@@ -122,11 +129,14 @@ describe("BaseCLI tests", () => {
       dummyStderr.writableStream,
       false,
       false,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
-      false,
-      true,
-      true,
+      mockKeyReader,
+      {
+        configFileSupportEnabled: true,
+        keyValueServiceEnabled: true,
+      },
     );
 
     let serviceProvider1Initialised = false;
@@ -140,21 +150,20 @@ describe("BaseCLI tests", () => {
     const SERVICE_2 = "service2";
 
     interface ServiceInterface {
-      serviceMethod(context: Context): void;
+      serviceMethod(context: Context): Promise<void>;
     }
 
     class DefaultService1 implements ServiceInterface {
       copyOfKeyValueService: KeyValueService | undefined;
 
-      serviceMethod(context: Context): void {
-        // should only have access to the modifierCommand KV scope
-        expect(this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
+      async serviceMethod(context: Context): Promise<void> {
+        expect(await this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "modifierCommand",
         );
-        this.copyOfKeyValueService!.setKey(
+        await this.copyOfKeyValueService!.setKey(
           "name",
           "defaultService1+modifierCommand",
         );
@@ -163,10 +172,9 @@ describe("BaseCLI tests", () => {
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the modifierCommand KV scope
-        expect(keyValueService.hasKey("name")).toBeTrue();
+        expect(await keyValueService.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "defaultService1+modifierCommand",
         );
@@ -178,13 +186,12 @@ describe("BaseCLI tests", () => {
     class DefaultService2 implements ServiceInterface {
       copyOfKeyValueService: KeyValueService | undefined;
 
-      serviceMethod(context: Context): void {
-        // should only have access to the modifierCommand KV scope
-        expect(this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
-        expect(this.copyOfKeyValueService!.getKey("name")).toEqual(
+      async serviceMethod(context: Context): Promise<void> {
+        expect(await this.copyOfKeyValueService!.hasKey("name")).toBeTrue();
+        expect(await this.copyOfKeyValueService!.getKey("name")).toEqual(
           "subCommand",
         );
-        this.copyOfKeyValueService!.setKey(
+        await this.copyOfKeyValueService!.setKey(
           "name",
           "defaultService2+subCommand",
         );
@@ -193,10 +200,9 @@ describe("BaseCLI tests", () => {
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the subCommand KV scope
-        expect(keyValueService.hasKey("name")).toBeTrue();
+        expect(await keyValueService.hasKey("name")).toBeTrue();
         expect(
-          this.copyOfKeyValueService!.getKey("name"),
+          await this.copyOfKeyValueService!.getKey("name"),
         ).toEqual(
           "defaultService2+subCommand",
         );
@@ -211,7 +217,7 @@ describe("BaseCLI tests", () => {
 
       defaultService1: DefaultService1 | undefined;
 
-      provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+      getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
         this.defaultService1 = new DefaultService1();
         return Promise.resolve({
           service: this.defaultService1,
@@ -219,20 +225,17 @@ describe("BaseCLI tests", () => {
         });
       }
 
-      initService(context: Context): Promise<void> {
+      async initService(context: Context): Promise<void> {
         const keyValueService = context.getServiceById(
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the ServiceProvider1 KV scope
-        expect(keyValueService.hasKey("name")).toBeFalse();
-        keyValueService.setKey("name", "defaultService2");
+        expect(await keyValueService.hasKey("name")).toBeFalse();
+        await keyValueService.setKey("name", "defaultService2");
 
-        // take a copy to check later when service is accessed via a command
         this.defaultService1!.copyOfKeyValueService = keyValueService;
 
         serviceProvider1Initialised = true;
-        return Promise.resolve(undefined);
       }
     }
 
@@ -242,7 +245,7 @@ describe("BaseCLI tests", () => {
 
       defaultService2: DefaultService2 | undefined;
 
-      provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+      getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
         this.defaultService2 = new DefaultService2();
         return Promise.resolve({
           service: this.defaultService2,
@@ -250,20 +253,17 @@ describe("BaseCLI tests", () => {
         });
       }
 
-      initService(context: Context): Promise<void> {
+      async initService(context: Context): Promise<void> {
         const keyValueService = context.getServiceById(
           KEY_VALUE_SERVICE_ID,
         ) as KeyValueService;
 
-        // should only have access to the ServiceProvider2 KV scope
-        expect(keyValueService.hasKey("name")).toBeFalse();
-        keyValueService.setKey("name", "defaultService2");
+        expect(await keyValueService.hasKey("name")).toBeFalse();
+        await keyValueService.setKey("name", "defaultService2");
 
-        // take a copy to check later when service is accessed via a command
         this.defaultService2!.copyOfKeyValueService = keyValueService;
 
         serviceProvider2Initialised = true;
-        return Promise.resolve(undefined);
       }
     }
 
@@ -282,37 +282,33 @@ describe("BaseCLI tests", () => {
     };
     const subCommand = getSubCommand("command", [option], []);
 
-    modifierCommand.execute = (context): Promise<void> => {
+    modifierCommand.execute = async (context): Promise<void> => {
       const keyValueService = context.getServiceById(
         KEY_VALUE_SERVICE_ID,
       ) as KeyValueService;
 
-      // should only have access to the modifierCommand KV scope
-      expect(keyValueService.hasKey("name")).toBeFalse();
-      keyValueService.setKey("name", "modifierCommand");
+      expect(await keyValueService.hasKey("name")).toBeFalse();
+      await keyValueService.setKey("name", "modifierCommand");
 
       const service1 = context.getServiceById(SERVICE_1) as ServiceInterface;
 
-      service1.serviceMethod(context);
+      await service1.serviceMethod(context);
 
       modifierHasRun = true;
-      return Promise.resolve();
     };
-    subCommand.execute = (context): Promise<void> => {
+    subCommand.execute = async (context): Promise<void> => {
       const keyValueService = context.getServiceById(
         KEY_VALUE_SERVICE_ID,
       ) as KeyValueService;
 
-      // should only have access to the subCommand KV scope
-      expect(keyValueService.hasKey("name")).toBeFalse();
-      keyValueService.setKey("name", "subCommand");
+      expect(await keyValueService.hasKey("name")).toBeFalse();
+      await keyValueService.setKey("name", "subCommand");
 
       const service2 = context.getServiceById(SERVICE_2) as ServiceInterface;
 
-      service2.serviceMethod(context);
+      await service2.serviceMethod(context);
 
       subHasRun = true;
-      return Promise.resolve();
     };
 
     baseCLI.addServiceProvider(new ServiceProvider1());

package/tests/command/CompletionCommand.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from "bun:test";
+import {
+  CompletionCompleteSubCommand,
+  CompletionGroupCommand,
+  CompletionIntegrationSubCommand,
+} from "../../src/command/CompletionCommand.ts";
+
+describe("CompletionIntegrationSubCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.name).toEqual("integration");
+  });
+
+  test("has shell positional with allowable values", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.positionals.length).toEqual(1);
+    expect(cmd.positionals[0]!.name).toEqual("shell");
+    expect(cmd.positionals[0]!.allowableValues).toEqual([
+      "bash",
+      "zsh",
+      "fish",
+      "powershell",
+    ]);
+  });
+
+  test("has optional config-path option", () => {
+    const cmd = new CompletionIntegrationSubCommand();
+    expect(cmd.options.length).toEqual(1);
+    expect(cmd.options[0]!.name).toEqual("config-path");
+    expect(cmd.options[0]!.isOptional).toEqual(true);
+  });
+});
+
+describe("CompletionCompleteSubCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionCompleteSubCommand();
+    expect(cmd.name).toEqual("complete");
+  });
+
+  test("has shell positional and vararg args positional", () => {
+    const cmd = new CompletionCompleteSubCommand();
+    expect(cmd.positionals.length).toEqual(2);
+    expect(cmd.positionals[0]!.name).toEqual("shell");
+    expect(cmd.positionals[1]!.name).toEqual("args");
+    expect(cmd.positionals[1]!.isVarargMultiple).toEqual(true);
+    expect(cmd.positionals[1]!.isVarargOptional).toEqual(true);
+  });
+});
+
+describe("CompletionGroupCommand", () => {
+  test("has correct name", () => {
+    const cmd = new CompletionGroupCommand(
+      new CompletionIntegrationSubCommand(),
+      new CompletionCompleteSubCommand(),
+    );
+    expect(cmd.name).toEqual("completions");
+  });
+
+  test("has two member sub-commands", () => {
+    const cmd = new CompletionGroupCommand(
+      new CompletionIntegrationSubCommand(),
+      new CompletionCompleteSubCommand(),
+    );
+    expect(cmd.memberSubCommands.length).toEqual(2);
+    expect(cmd.memberSubCommands[0]!.name).toEqual("integration");
+    expect(cmd.memberSubCommands[1]!.name).toEqual("complete");
+  });
+});

package/tests/command/UsageCommand.test.ts

@@ -9,8 +9,8 @@ import type Context from "../../src/api/Context.ts";
 import type Command from "../../src/api/command/Command.ts";
 import StreamString from "../fixtures/StreamString.ts";
 import { expectStringEquals } from "../fixtures/util.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
 
 describe("UsageCommand tests", () => {
   test("Usage works", async () => {
@@ -21,6 +21,7 @@ describe("UsageCommand tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );

package/tests/command/VersionCommand.test.ts

@@ -6,8 +6,8 @@ import { PRINTER_SERVICE_ID } from "../../src/api/service/core/PrinterService.ts
 import DefaultPrinterService from "../../src/service/printer/DefaultPrinterService.ts";
 import StreamString from "../fixtures/StreamString.ts";
 import { expectStringEquals } from "../fixtures/util.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
 
 describe("VersionCommand tests", () => {
   test("Version works", async () => {
@@ -18,6 +18,7 @@ describe("VersionCommand tests", () => {
       dummyStderr.writableStream,
       true,
       true,
+      new TtyTerminal(dummyStdout.writeStream),
       new TtyTerminal(dummyStderr.writeStream),
       new TtyStyler(3),
     );

package/tests/fixtures/Context.ts

@@ -6,8 +6,10 @@ import DefaultKeyValueService from "../../src/service/configuration/DefaultKeyVa
 import { KEY_VALUE_SERVICE_ID } from "../../src/api/service/core/KeyValueService.ts";
 import type Context from "../../src/api/Context.ts";
 import WritableStreamString from "./StreamString.ts";
-import TtyTerminal from "../../src/service/printer/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/service/printer/terminal/TtyStyler.ts";
+import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
+import TtyStyler from "../../src/terminal/TtyStyler.ts";
+import { TABLE_GENERATOR_SERVICE_ID } from "../../src/api/service/core/TableGeneratorService.ts";
+import DefaultTableGeneratorService from "../../src/service/tableGenerator/DefaultTableGeneratorService.ts";
 
 export function getContext(
   streamString: WritableStreamString,
@@ -19,6 +21,7 @@ export function getContext(
     false,
     false,
     new TtyTerminal(streamString.writeStream),
+    new TtyTerminal(streamString.writeStream),
     new TtyStyler(3),
   );
 
@@ -28,6 +31,10 @@ export function getContext(
     KEY_VALUE_SERVICE_ID,
     new DefaultKeyValueService(),
   );
+  defaultContext.addServiceInstance(
+    TABLE_GENERATOR_SERVICE_ID,
+    new DefaultTableGeneratorService(),
+  );
 
   return defaultContext;
 }

package/tests/fixtures/util.ts

@@ -20,7 +20,7 @@ export function expectStringEquals(actual: string, expected: string) {
 }
 
 export function expectBytesEquals(actual: string, expected: Uint8Array) {
-  expect(encoder.encode(actual)).toEqual(expected);
+  expect(encoder.encode(actual)).toEqual(expected as Uint8Array<ArrayBuffer>);
 }
 
 export function sleep(ms: number) {

package/tests/runtime/command/CommandValidator.test.ts

@@ -90,6 +90,77 @@ describe("CommandValidator tests", () => {
       .toThrow();
   });
 
+  test(
+    "SubCommand validation fails due to boolean argument type not supporting allowable values",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.BOOLEAN,
+        allowableValues: ["goo"],
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
+  test(
+    "SubCommand validation fails due to boolean argument type not supporting case sensitivity",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.BOOLEAN,
+        isCaseInsensitive: true,
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
+  test(
+    "SubCommand validation fails due to number argument type not supporting case insensitivity",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.NUMBER,
+        isCaseInsensitive: false,
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
+  test(
+    "SubCommand validation fails due to string argument type not supporting value range",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.STRING,
+        minValueInclusive: 1,
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
+  test(
+    "SubCommand validation fails due to number argument type not supporting value range and allowable values",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.NUMBER,
+        allowableValues: [1],
+        minValueInclusive: 1,
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
   test(
     "SubCommand validation fails due to option default value" +
       " not matching any values specified in argument valid values",
@@ -106,6 +177,38 @@ describe("CommandValidator tests", () => {
     },
   );
 
+  test(
+    "SubCommand validation fails due to option default value" +
+      " not matching any values specified in argument valid values with case sensitivity",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.STRING,
+        defaultValue: "bar",
+        allowableValues: ["BAR"],
+      }], []);
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command))
+        .toThrow();
+    },
+  );
+
+  test(
+    "SubCommand validation successed with option default value" +
+      " matching value specified in argument valid values with case insensitivity",
+    () => {
+      const command = getSubCommand("command", [{
+        name: "foo",
+        type: ArgumentValueTypeName.STRING,
+        defaultValue: "bar",
+        allowableValues: ["BAR"],
+        isCaseInsensitive: true,
+      }], []);
+
+      new CommandValidator(getCLIConfig()).validate(command);
+    },
+  );
+
   test(
     "SubCommand validation fails due to the type of option defaultValue" +
       " not matching the type specified in argument type",

package/tests/runtime/parser.test.ts

@@ -386,7 +386,7 @@ describe("parser tests", () => {
       },
     };
 
-    ((argumentValues.alpha as Array<PopulatedArgumentValues>)[0].beta as Array<
+    ((argumentValues.alpha as Array<PopulatedArgumentValues>)[0]!.beta as Array<
       PopulatedArgumentValues
     >)[1] = {
       gamma: "foo2",
@@ -439,12 +439,14 @@ describe("parser tests", () => {
     };
 
     // these are still stored as strings as the validation (and type conversion) failed fast
-    (((argumentValues.alpha as Array<PopulatedArgumentValues>)[0].beta as Array<
-      PopulatedArgumentValues
-    >)[1].delta as Array<ArgumentValueType>)[0] = "0";
-    (((argumentValues.alpha as Array<PopulatedArgumentValues>)[0].beta as Array<
-      PopulatedArgumentValues
-    >)[1].delta as Array<ArgumentValueType>)[2] = "2";
+    (((argumentValues.alpha as Array<PopulatedArgumentValues>)[0]!
+      .beta as Array<
+        PopulatedArgumentValues
+      >)[1]!.delta as Array<ArgumentValueType>)[0] = "0";
+    (((argumentValues.alpha as Array<PopulatedArgumentValues>)[0]!
+      .beta as Array<
+        PopulatedArgumentValues
+      >)[1]!.delta as Array<ArgumentValueType>)[2] = "2";
 
     expectParseResult(parseResult, {
       command: subCommand,

package/tests/runtime/registry/DefaultServiceProviderRegistry.test.ts

@@ -14,7 +14,7 @@ function getServiceProvider(
   return {
     serviceId,
     servicePriority,
-    provide(_cliConfig: CLIConfig): Promise<ServiceInfo> {
+    getServiceInfo(_cliConfig: CLIConfig): Promise<ServiceInfo> {
       return Promise.resolve({
         service: {},
         commands: [],
@@ -36,7 +36,7 @@ describe("DefaultServiceProviderRegistry tests", () => {
     serviceProviderRegistry.addServiceProvider(serviceProvider2);
 
     const orderedServices = serviceProviderRegistry.getServiceProviders();
-    expect(orderedServices[0].servicePriority).toEqual(2);
-    expect(orderedServices[1].servicePriority).toEqual(1);
+    expect(orderedServices[0]!.servicePriority).toEqual(2);
+    expect(orderedServices[1]!.servicePriority).toEqual(1);
   });
 });

package/tests/runtime/runner.test.ts

@@ -689,6 +689,42 @@ describe("runner tests", () => {
     expect(hasRun).toBeFalse();
   });
 
+  test("No command recognised", async () => {
+    const streamString = new StreamString();
+    let hasRun = false;
+    const option = {
+      name: "foo",
+      type: ArgumentValueTypeName.STRING,
+      shortAlias: "f",
+    };
+    const subCommand = getSubCommand("command", [option], []);
+
+    subCommand.execute = (): Promise<void> => {
+      hasRun = true;
+      return Promise.resolve();
+    };
+
+    const commandRegistry = new DefaultCommandRegistry([subCommand]);
+    const runResult = await run(
+      ["blah", "comman", "ommand"],
+      commandRegistry,
+      getServiceProviderRegistry(),
+      undefined,
+      getContext(streamString),
+    );
+
+    expect(runResult.runState).toEqual(RunState.NO_COMMAND);
+    expectStringIncludes(
+      streamString.getString(),
+      "No command recognised",
+    );
+    expectStringIncludes(
+      streamString.getString(),
+      "Possible matches: command\n",
+    );
+    expect(hasRun).toBeFalse();
+  });
+
   test("Unknown arg warning in non-global run", async () => {
     const streamString = new StreamString();
     let hasRun = false;