@flowscripter/dynamic-cli-framework 1.0.0

package/tests/fixtures/Command.ts

@@ -0,0 +1,229 @@
+import type GroupCommand from "../../src/api/command/GroupCommand.ts";
+import type GlobalCommand from "../../src/api/command/GlobalCommand.ts";
+import type SubCommand from "../../src/api/command/SubCommand.ts";
+import {
+  ArgumentValueTypeName,
+  ComplexValueTypeName,
+} from "../../src/api/argument/ArgumentValueTypes.ts";
+import type ComplexOption from "../../src/api/argument/ComplexOption.ts";
+import type Positional from "../../src/api/argument/Positional.ts";
+import type GlobalCommandArgument from "../../src/api/argument/GlobalCommandArgument.ts";
+import type GlobalModifierCommand from "../../src/api/command/GlobalModifierCommand.ts";
+import type Option from "../../src/api/argument/Option.ts";
+
+export function getGroupCommand(
+  name = "groupCommand",
+  memberSubCommands = [getSubCommandWithOption("foo")],
+): GroupCommand {
+  return {
+    name,
+    memberSubCommands,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getGlobalModifierCommand(
+  name = "globalModifierCommand",
+  shortAlias: string | undefined = undefined,
+  withArg = false,
+  mandatoryArg = false,
+): GlobalModifierCommand {
+  return {
+    name,
+    shortAlias,
+    executePriority: 1,
+    argument: withArg
+      ? {
+        type: ArgumentValueTypeName.STRING,
+        isOptional: !mandatoryArg,
+      }
+      : undefined,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getGlobalModifierCommandWithArgument(
+  name: string,
+  shortAlias: string,
+  executePriority = 1,
+  argument?: GlobalCommandArgument,
+  enableConfiguration = false,
+): GlobalModifierCommand {
+  return {
+    name,
+    enableConfiguration,
+    shortAlias,
+    executePriority,
+    argument,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getGlobalCommand(
+  name = "globalCommand",
+  withArg = false,
+  mandatoryArg = false,
+  enableConfiguration = false,
+  configurationKey?: string,
+): GlobalCommand {
+  return {
+    name,
+    enableConfiguration,
+    argument: withArg
+      ? {
+        type: ArgumentValueTypeName.STRING,
+        isOptional: !mandatoryArg,
+        configurationKey,
+      }
+      : undefined,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getGlobalCommandWithShortAlias(
+  name: string,
+  shortAlias: string,
+  argument?: GlobalCommandArgument,
+): GlobalCommand {
+  return {
+    name,
+    shortAlias,
+    argument,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getSubCommandWithOptionAndPositional(): SubCommand {
+  return {
+    name: "subCommand",
+    options: [{
+      name: "goo",
+      shortAlias: "g",
+      type: ArgumentValueTypeName.STRING,
+    }],
+    positionals: [{
+      name: "foo",
+      type: ArgumentValueTypeName.STRING,
+    }],
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getSubCommand(
+  name: string,
+  options: Array<Option | ComplexOption>,
+  positionals: Array<Positional> = [],
+  enableConfiguration = false,
+): SubCommand {
+  return {
+    name,
+    options,
+    positionals,
+    enableConfiguration,
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getSubCommandWithOption(
+  name = "subCommand",
+  withArg = false,
+  mandatoryArg = false,
+  multiple = false,
+  type: ArgumentValueTypeName = ArgumentValueTypeName.STRING,
+  defaultValue?: string,
+  enableConfiguration = false,
+  configurationKey?: string,
+): SubCommand {
+  return {
+    name,
+    description: "good",
+    enableConfiguration,
+    options: withArg
+      ? [{
+        name: "foo",
+        type,
+        isOptional: !mandatoryArg,
+        isArray: multiple,
+        defaultValue,
+        configurationKey,
+      }]
+      : [],
+    positionals: [],
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getSubCommandWithPositional(
+  name: string,
+  optional = false,
+  multiple = false,
+  type: ArgumentValueTypeName = ArgumentValueTypeName.STRING,
+  enableConfiguration = false,
+  configurationKey?: string,
+): SubCommand {
+  return {
+    name,
+    description: "good",
+    enableConfiguration,
+    options: [],
+    positionals: [{
+      name: "foo",
+      type,
+      isVarargOptional: optional,
+      isVarargMultiple: multiple,
+      configurationKey,
+    }],
+    execute: async (): Promise<void> => {},
+  };
+}
+
+export function getSubCommandWithComplexOptions(
+  enableConfiguration = false,
+  betaIsArray = false,
+  deltaIsArray = false,
+): SubCommand {
+  return {
+    name: "subCommand",
+    enableConfiguration,
+    options: [{
+      name: "alpha",
+      shortAlias: "a",
+      type: ComplexValueTypeName.COMPLEX,
+      isArray: true,
+      properties: [{
+        name: "beta",
+        shortAlias: "b",
+        type: ComplexValueTypeName.COMPLEX,
+        isArray: betaIsArray,
+        properties: [{
+          name: "gamma",
+          shortAlias: "g",
+          type: ArgumentValueTypeName.STRING,
+        }, {
+          name: "delta",
+          shortAlias: "d",
+          type: ArgumentValueTypeName.NUMBER,
+          isArray: true,
+        }],
+      }],
+    }, {
+      name: "epsilon",
+      shortAlias: "e",
+      type: ComplexValueTypeName.COMPLEX,
+      properties: [{
+        name: "gamma",
+        shortAlias: "g",
+        type: ArgumentValueTypeName.STRING,
+        configurationKey: "FOO_BAR_A",
+      }, {
+        name: "delta",
+        shortAlias: "d",
+        type: ArgumentValueTypeName.NUMBER,
+        configurationKey: "FOO_BAR_B",
+        isArray: deltaIsArray,
+      }],
+    }],
+    positionals: [],
+    execute: async (): Promise<void> => {},
+  };
+}

package/tests/fixtures/CommandRegistry.ts

@@ -0,0 +1,8 @@
+import DefaultCommandRegistry from "../../src/runtime/registry/DefaultCommandRegistry.ts";
+import type Command from "../../src/api/command/Command.ts";
+
+export function getCommandRegistry(
+  commands?: Array<Command>,
+): DefaultCommandRegistry {
+  return new DefaultCommandRegistry(commands);
+}

package/tests/fixtures/ConfigurationServiceProvider.ts

@@ -0,0 +1,28 @@
+import ConfigurationServiceProvider from "../../src/service/configuration/ConfigurationServiceProvider.ts";
+import type {
+  ArgumentSingleValueType,
+  ArgumentValues,
+} from "../../src/api/argument/ArgumentValueTypes.ts";
+import type Context from "../../src/api/Context.ts";
+
+class DummyConfigurationServiceProvider extends ConfigurationServiceProvider {
+  constructor(
+    servicePriority: number,
+    defaultsData: Map<string, ArgumentValues | ArgumentSingleValueType>,
+  ) {
+    super(servicePriority, false, true);
+
+    this.defaultsData = defaultsData;
+  }
+
+  public override initService(_context: Context): Promise<void> {
+    return Promise.resolve();
+  }
+}
+
+export function getConfigurationServiceProvider(
+  servicePriority: number,
+  defaultsData: Map<string, ArgumentValues | ArgumentSingleValueType>,
+) {
+  return new DummyConfigurationServiceProvider(servicePriority, defaultsData);
+}

package/tests/fixtures/Context.ts

@@ -0,0 +1,33 @@
+import DefaultContext from "../../src/runtime/DefaultContext.ts";
+import { getCLIConfig } from "./CLIConfig.ts";
+import { PRINTER_SERVICE_ID } from "../../src/api/service/core/PrinterService.ts";
+import DefaultPrinterService from "../../src/service/printer/DefaultPrinterService.ts";
+import DefaultKeyValueService from "../../src/service/configuration/DefaultKeyValueService.ts";
+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";
+
+export function getContext(
+  streamString: WritableStreamString,
+): Context {
+  const defaultContext = new DefaultContext(getCLIConfig());
+  const defaultPrinterService = new DefaultPrinterService(
+    streamString.writableStream,
+    streamString.writableStream,
+    false,
+    false,
+    new TtyTerminal(streamString.writeStream),
+    new TtyStyler(3),
+  );
+
+  defaultPrinterService.colorEnabled = false;
+  defaultContext.addServiceInstance(PRINTER_SERVICE_ID, defaultPrinterService);
+  defaultContext.addServiceInstance(
+    KEY_VALUE_SERVICE_ID,
+    new DefaultKeyValueService(),
+  );
+
+  return defaultContext;
+}

package/tests/fixtures/ServiceProviderRegistry.ts

@@ -0,0 +1,16 @@
+import DefaultServiceProviderRegistry from "../../src/runtime/registry/DefaultServiceProviderRegistry.ts";
+import type ServiceProviderRegistry from "../../src/runtime/registry/ServiceProviderRegistry.ts";
+import type { ServiceProvider } from "../../src/api/service/ServiceProvider.ts";
+
+export function getServiceProviderRegistry(
+  serviceProviders?: Array<ServiceProvider>,
+): ServiceProviderRegistry {
+  const serviceProviderRegistry = new DefaultServiceProviderRegistry([]);
+
+  if (serviceProviders) {
+    serviceProviders.forEach((serviceProvider) =>
+      serviceProviderRegistry.addServiceProvider(serviceProvider)
+    );
+  }
+  return serviceProviderRegistry;
+}

package/tests/fixtures/StreamString.ts

@@ -0,0 +1,37 @@
+import { Buffer } from "node:buffer";
+import { WriteStream } from "node:tty";
+import { PassThrough } from "node:stream";
+import { WritableStream } from "node:stream/web";
+
+export default class WritableStreamString {
+  private chunks: string[];
+  writableStream: WritableStream<Uint8Array>;
+  writeStream: WriteStream;
+
+  constructor() {
+    this.chunks = [];
+
+    this.writableStream = new WritableStream<Uint8Array>({
+      write: (chunk: Uint8Array) => {
+        const decoder = new TextDecoder();
+        const chunkString = decoder.decode(chunk);
+        this.chunks.push(chunkString);
+      },
+    });
+
+    const passThrough = new PassThrough();
+    this.writeStream = passThrough as unknown as WriteStream;
+
+    passThrough.on("data", (chunk) => {
+      if (Buffer.isBuffer(chunk)) {
+        this.chunks.push(chunk.toString());
+      } else {
+        this.chunks.push(String(chunk));
+      }
+    });
+  }
+
+  getString(): string {
+    return this.chunks.join("");
+  }
+}

package/tests/fixtures/util.ts

@@ -0,0 +1,41 @@
+import { expect } from "bun:test";
+import { stripVTControlCharacters } from "node:util";
+import { WritableStream } from "node:stream/web";
+
+const encoder = new TextEncoder();
+
+export function expectStringIncludes(actual: string, expected: string) {
+  expect(stripVTControlCharacters(actual).includes(expected)).toBeTrue();
+}
+
+export function expectStringNotIncludes(
+  actual: string,
+  expected: string,
+) {
+  expect(stripVTControlCharacters(actual).includes(expected)).toBeFalse();
+}
+
+export function expectStringEquals(actual: string, expected: string) {
+  expect(stripVTControlCharacters(actual)).toEqual(expected);
+}
+
+export function expectBytesEquals(actual: string, expected: Uint8Array) {
+  expect(encoder.encode(actual)).toEqual(expected);
+}
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function write(
+  writableStream: WritableStream,
+  message: string,
+) {
+  const encoded = encoder.encode(message);
+  const writer = writableStream.getWriter();
+
+  await writer.ready;
+  await writer.write(encoded);
+
+  writer.releaseLock();
+}

package/tests/runtime/DefaultContext.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, test } from "bun:test";
+import DefaultContext from "../../src/runtime/DefaultContext.ts";
+import { getCLIConfig } from "../fixtures/CLIConfig.ts";
+
+describe("DefaultContext Tests", () => {
+  test("Check for duplicate service ID", () => {
+    const context = new DefaultContext(getCLIConfig());
+
+    context.addServiceInstance("foo", {});
+    expect(() => context.addServiceInstance("foo", {})).toThrow();
+  });
+
+  test("Check lookup by ID", () => {
+    const context = new DefaultContext(getCLIConfig());
+
+    context.addServiceInstance("foo", "bar");
+
+    expect(context.getServiceById("foo")).toEqual("bar");
+  });
+});

package/tests/runtime/argument/ArgumentTypeGuards.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test";
+import type ComplexOption from "../../../src/api/argument/ComplexOption.ts";
+import {
+  ArgumentValueTypeName,
+  ComplexValueTypeName,
+} from "../../../src/api/argument/ArgumentValueTypes.ts";
+import type Positional from "../../../src/api/argument/Positional.ts";
+import type GlobalCommandArgument from "../../../src/api/argument/GlobalCommandArgument.ts";
+import { isComplexOption } from "../../../src/runtime/argument/ArgumentTypeGuards.ts";
+import type Option from "../../../src/api/argument/Option.ts";
+
+function getComplexOption(): ComplexOption {
+  return {
+    name: "option",
+    type: ComplexValueTypeName.COMPLEX,
+    properties: [
+      getOption(),
+    ],
+  };
+}
+
+function getOption(): Option {
+  return {
+    name: "option",
+    type: ArgumentValueTypeName.STRING,
+  };
+}
+
+function getPositional(): Positional {
+  return {
+    name: "positional",
+    type: ArgumentValueTypeName.STRING,
+  };
+}
+
+function getGlobalCommandArgument(): GlobalCommandArgument {
+  return {
+    type: ArgumentValueTypeName.STRING,
+  };
+}
+
+describe("ArgumentTypeGuards Tests", () => {
+  test("isComplexOption works", () => {
+    expect(isComplexOption(getComplexOption())).toBeTrue();
+    expect(isComplexOption(getOption())).toBeFalse();
+    expect(isComplexOption(getPositional())).toBeFalse();
+    expect(isComplexOption(getGlobalCommandArgument())).toBeFalse();
+  });
+});

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

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getGlobalCommand,
+  getGlobalModifierCommand,
+  getGroupCommand,
+  getSubCommandWithOption,
+} from "../../fixtures/Command.ts";
+import {
+  isGlobalCommand,
+  isGlobalModifierCommand,
+  isGroupCommand,
+  isSubCommand,
+} from "../../../src/runtime/command/CommandTypeGuards.ts";
+
+describe("CommandTypeGuards Tests", () => {
+  test("isSubCommand works", () => {
+    expect(isSubCommand(getSubCommandWithOption())).toBeTrue();
+    expect(isSubCommand(getGroupCommand())).toBeFalse();
+    expect(isSubCommand(getGlobalCommand())).toBeFalse();
+    expect(isSubCommand(getGlobalModifierCommand())).toBeFalse();
+  });
+
+  test("isGroupCommand works", () => {
+    expect(isGroupCommand(getSubCommandWithOption())).toBeFalse();
+    expect(isGroupCommand(getGroupCommand())).toBeTrue();
+    expect(isGroupCommand(getGlobalCommand())).toBeFalse();
+    expect(isGroupCommand(getGlobalModifierCommand())).toBeFalse();
+  });
+
+  test("isGlobalCommand works", () => {
+    expect(isGlobalCommand(getSubCommandWithOption())).toBeFalse();
+    expect(isGlobalCommand(getGroupCommand())).toBeFalse();
+    expect(isGlobalCommand(getGlobalCommand())).toBeTrue();
+    expect(isGlobalCommand(getGlobalModifierCommand())).toBeFalse();
+  });
+
+  test("isGlobalModifierCommand works", () => {
+    expect(isGlobalModifierCommand(getSubCommandWithOption())).toBeFalse();
+    expect(isGlobalModifierCommand(getGroupCommand())).toBeFalse();
+    expect(isGlobalModifierCommand(getGlobalCommand())).toBeFalse();
+    expect(isGlobalModifierCommand(getGlobalModifierCommand())).toBeTrue();
+  });
+});