@flowscripter/dynamic-cli-framework 1.1.6 → 1.2.0

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/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/values/argumentValueValidation.test.ts

@@ -994,6 +994,199 @@ describe("argumentValueValidation tests", () => {
     }]);
   });
 
+  test("Option with custom validator that passes", () => {
+    const option: Option = {
+      name: "foo",
+      type: ArgumentValueTypeName.STRING,
+      validate: () => undefined,
+    };
+    const invalidArguments: Array<InvalidArgument> = [];
+    expect(validateOptionValue(option, "hello", invalidArguments)).toEqual(
+      "hello",
+    );
+    expect(invalidArguments).toEqual([]);
+  });
+
+  test("Option with custom validator that fails", () => {
+    const option: Option = {
+      name: "foo",
+      type: ArgumentValueTypeName.STRING,
+      validate: (v) => (v as string).length < 3 ? "min 3 chars" : undefined,
+    };
+    const invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validateOptionValue(option, "ab", invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: option,
+      name: "foo",
+      value: "ab",
+      reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+      message: "min 3 chars",
+    }]);
+  });
+
+  test("Positional with custom validator that passes and fails", () => {
+    const positional: Positional = {
+      name: "count",
+      type: ArgumentValueTypeName.NUMBER,
+      validate: (v) => (v as number) % 2 !== 0 ? "must be even" : undefined,
+    };
+    let invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validatePositionalValue(positional, "4", invalidArguments),
+    ).toEqual(4);
+    expect(invalidArguments).toEqual([]);
+
+    invalidArguments = [];
+    expect(
+      validatePositionalValue(positional, "3", invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: positional,
+      name: "count",
+      value: 3,
+      reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+      message: "must be even",
+    }]);
+  });
+
+  test("GlobalCommand argument with custom validator that passes and fails", () => {
+    const globalCommandArgument: GlobalCommandArgument = {
+      type: ArgumentValueTypeName.STRING,
+      validate: (v) =>
+        (v as string).startsWith("x") ? undefined : "must start with x",
+    };
+    const globalCommand = getGlobalCommandWithShortAlias(
+      "globalCommand",
+      "f",
+      globalCommandArgument,
+    );
+    let invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validateGlobalCommandArgumentValue(
+        globalCommand,
+        "xfoo",
+        invalidArguments,
+      ),
+    ).toEqual("xfoo");
+    expect(invalidArguments).toEqual([]);
+
+    invalidArguments = [];
+    expect(
+      validateGlobalCommandArgumentValue(
+        globalCommand,
+        "bar",
+        invalidArguments,
+      ),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: globalCommandArgument,
+      name: "globalCommand",
+      value: "bar",
+      reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+      message: "must start with x",
+    }]);
+  });
+
+  test("Option isArray with custom validator checking uniqueness", () => {
+    const option: Option = {
+      name: "tags",
+      type: ArgumentValueTypeName.STRING,
+      isArray: true,
+      validate: (v) => {
+        const arr = v as string[];
+        return new Set(arr).size !== arr.length
+          ? "values must be unique"
+          : undefined;
+      },
+    };
+    let invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validateOptionValue(option, ["a", "b", "c"], invalidArguments),
+    ).toEqual(["a", "b", "c"]);
+    expect(invalidArguments).toEqual([]);
+
+    invalidArguments = [];
+    expect(
+      validateOptionValue(option, ["a", "b", "a"], invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: option,
+      name: "tags",
+      value: ["a", "b", "a"],
+      reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+      message: "values must be unique",
+    }]);
+  });
+
+  test("Positional isVarargMultiple with custom validator checking uniqueness", () => {
+    const positional: Positional = {
+      name: "ids",
+      type: ArgumentValueTypeName.NUMBER,
+      isVarargMultiple: true,
+      validate: (v) => {
+        const arr = v as number[];
+        return new Set(arr).size !== arr.length
+          ? "values must be unique"
+          : undefined;
+      },
+    };
+    let invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validatePositionalValue(positional, ["1", "2", "3"], invalidArguments),
+    ).toEqual([1, 2, 3]);
+    expect(invalidArguments).toEqual([]);
+
+    invalidArguments = [];
+    expect(
+      validatePositionalValue(positional, ["1", "2", "1"], invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: positional,
+      name: "ids",
+      value: [1, 2, 1],
+      reason: InvalidArgumentReason.CUSTOM_VALIDATION,
+      message: "values must be unique",
+    }]);
+  });
+
+  test("Custom validator not called when built-in validation fails", () => {
+    const option: Option = {
+      name: "foo",
+      type: ArgumentValueTypeName.NUMBER,
+      validate: () => {
+        throw new Error("should not be called");
+      },
+    };
+    const invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validateOptionValue(option, "notanumber", invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: option,
+      name: "foo",
+      value: "notanumber",
+      reason: InvalidArgumentReason.INCORRECT_VALUE_TYPE,
+    }]);
+  });
+
+  test("Custom validator not called when value is undefined and optional", () => {
+    const option: Option = {
+      name: "foo",
+      type: ArgumentValueTypeName.STRING,
+      isOptional: true,
+      validate: () => {
+        throw new Error("should not be called");
+      },
+    };
+    const invalidArguments: Array<InvalidArgument> = [];
+    expect(
+      validateOptionValue(option, undefined, invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([]);
+  });
+
   test("Invalid global command argument value", () => {
     let globalCommandArgument: GlobalCommandArgument = {
       type: ArgumentValueTypeName.STRING,

package/tests/service/argumentPrompter/ArgumentPrompterServiceProvider.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import ArgumentPrompterServiceProvider from "../../../src/service/argumentPrompter/ArgumentPrompterServiceProvider.ts";
+import { ARGUMENT_PROMPTER_SERVICE_ID } from "../../../src/api/service/core/ArgumentPrompterService.ts";
+import type ArgumentPrompterService from "../../../src/api/service/core/ArgumentPrompterService.ts";
+import DefaultContext from "../../../src/runtime/DefaultContext.ts";
+import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
+
+function getMockArgumentPrompterService(): ArgumentPrompterService {
+  return {
+    promptForMissingArguments: (parseResult) => Promise.resolve(parseResult),
+  };
+}
+
+describe("ArgumentPrompterServiceProvider tests", () => {
+  test("ArgumentPrompterServiceProvider has correct serviceId", () => {
+    const provider = new ArgumentPrompterServiceProvider(
+      100,
+      getMockArgumentPrompterService(),
+    );
+
+    expect(provider.serviceId).toEqual(ARGUMENT_PROMPTER_SERVICE_ID);
+  });
+
+  test("ArgumentPrompterServiceProvider getServiceInfo returns no commands", async () => {
+    const argPrompterService = getMockArgumentPrompterService();
+    const provider = new ArgumentPrompterServiceProvider(
+      100,
+      argPrompterService,
+    );
+    const cliConfig = getCLIConfig();
+
+    const serviceInfo = await provider.getServiceInfo(cliConfig);
+
+    expect(serviceInfo.service).toBe(argPrompterService);
+    expect(serviceInfo.commands.length).toEqual(0);
+  });
+
+  test("ArgumentPrompterServiceProvider initService resolves", async () => {
+    const provider = new ArgumentPrompterServiceProvider(
+      100,
+      getMockArgumentPrompterService(),
+    );
+    const context = new DefaultContext(getCLIConfig());
+
+    await expect(provider.initService(context)).resolves.toBeUndefined();
+  });
+});