@flowscripter/dynamic-cli-framework 1.0.0

package/tests/service/syntaxHighlighter/DefaultSyntaxHighlighterService.test.ts

@@ -0,0 +1,123 @@
+import { describe, expect, test } from "bun:test";
+import { expectBytesEquals } from "../../fixtures/util.ts";
+import DefaultSyntaxHighlighterService from "../../../src/service/syntaxHighlighter/DefaultSyntaxHighlighterService.ts";
+import yaml from "highlight.js/lib/languages/yaml";
+
+describe("DefaultSyntaxHighlighterService Tests", () => {
+  test("JSON registered by default", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    expect(syntaxHighlighterService.getRegisteredSyntaxes()).toEqual(["json"]);
+  });
+
+  test("Cannot register a syntax if already registered", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    expect(() => syntaxHighlighterService.registerSyntax("jSon", yaml))
+      .toThrow();
+  });
+
+  test("Can register new syntax", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    syntaxHighlighterService.registerSyntax("yaml", yaml);
+    expect(syntaxHighlighterService.getRegisteredSyntaxes()).toEqual([
+      "json",
+      "yaml",
+    ]);
+  });
+
+  test("Cannot highlight with unknown syntax", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    expect(() => syntaxHighlighterService.highlight("foo: 1", "yaml"))
+      .toThrow();
+  });
+
+  test("Can highlight with JSON syntax", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    syntaxHighlighterService.registerSyntax("yaml", yaml);
+
+    const highlighted = syntaxHighlighterService.highlight(
+      "{ foo: 1 }",
+      "json",
+    );
+    expectBytesEquals(
+      highlighted,
+      new Uint8Array([
+        123,
+        32,
+        102,
+        111,
+        111,
+        58,
+        32,
+        27,
+        91,
+        51,
+        54,
+        109,
+        49,
+        27,
+        91,
+        51,
+        57,
+        109,
+        32,
+        125,
+      ]),
+    );
+  });
+
+  test("Can highlight with newly registered syntax", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+
+    syntaxHighlighterService.registerSyntax("yaml", yaml);
+
+    const highlighted = syntaxHighlighterService.highlight("foo: 1", "yaml");
+    expectBytesEquals(
+      highlighted,
+      new Uint8Array([
+        27,
+        91,
+        51,
+        51,
+        109,
+        102,
+        111,
+        111,
+        58,
+        27,
+        91,
+        51,
+        57,
+        109,
+        32,
+        27,
+        91,
+        51,
+        54,
+        109,
+        49,
+        27,
+        91,
+        51,
+        57,
+        109,
+      ]),
+    );
+  });
+
+  test("Skipped if color disabled", () => {
+    const syntaxHighlighterService = new DefaultSyntaxHighlighterService();
+    syntaxHighlighterService.colorEnabled = false;
+
+    const highlighted = syntaxHighlighterService.highlight(
+      "{ foo: 1 }",
+      "json",
+    );
+
+    expect(highlighted).toEqual("{ foo: 1 }");
+  });
+});

package/tests/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import DefaultContext from "../../../src/runtime/DefaultContext.ts";
+import { getCLIConfig } from "../../fixtures/CLIConfig.ts";
+import SyntaxHighlighterServiceProvider from "../../../src/service/syntaxHighlighter/SyntaxHighlighterServiceProvider.ts";
+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 TtyTerminal from "../../../src/service/printer/terminal/TtyTerminal.ts";
+import TtyStyler from "../../../src/service/printer/terminal/TtyStyler.ts";
+
+describe("SyntaxHighlighterServiceProvider Tests", () => {
+  test("SyntaxHighlighterServiceProvider provide and initService works", async () => {
+    const dummyStdout = new StreamString();
+    const dummyStderr = new StreamString();
+    const syntaxHighlighterServiceProvider =
+      new SyntaxHighlighterServiceProvider(
+        100,
+      );
+    const cliConfig = getCLIConfig();
+    const context = new DefaultContext(cliConfig);
+
+    context.addServiceInstance(
+      PRINTER_SERVICE_ID,
+      new DefaultPrinterService(
+        dummyStdout.writableStream,
+        dummyStderr.writableStream,
+        true,
+        true,
+        new TtyTerminal(dummyStderr.writeStream),
+        new TtyStyler(3),
+      ),
+    );
+
+    const serviceInfo = await syntaxHighlighterServiceProvider.provide(
+      cliConfig,
+    );
+    expect(serviceInfo.commands.length).toEqual(0);
+
+    await syntaxHighlighterServiceProvider.initService(context);
+  });
+});

package/tests/util/configHelper.test.ts

@@ -0,0 +1,275 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getGlobalCommandArgumentConfigurationKey,
+  getSubCommandArgumentConfigurationKey,
+} from "../../src/util/configHelper.ts";
+import { getCLIConfig } from "../fixtures/CLIConfig.ts";
+import {
+  getGlobalCommand,
+  getSubCommandWithComplexOptions,
+  getSubCommandWithOption,
+  getSubCommandWithPositional,
+} from "../fixtures/Command.ts";
+import { ArgumentValueTypeName } from "../../src/api/argument/ArgumentValueTypes.ts";
+import type ComplexOption from "../../src/api/argument/ComplexOption.ts";
+import type Option from "../../src/api/argument/Option.ts";
+import type SubCommandArgument from "../../src/api/argument/SubCommandArgument.ts";
+
+describe("configHelper Tests", () => {
+  test("getConfigurationKey works for global argument", () => {
+    let command = getGlobalCommand("blah", true);
+
+    expect(
+      getGlobalCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        command.argument!,
+      ),
+    ).toBeUndefined();
+
+    command = getGlobalCommand("blah", true, false, true);
+
+    expect(
+      getGlobalCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        command.argument!,
+      ),
+    ).toEqual(
+      "FOO_BLAH",
+    );
+
+    command = getGlobalCommand("blah", true, false, true, "FOO_BAR");
+
+    expect(
+      getGlobalCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        command.argument!,
+      ),
+      "FOO_BAR",
+    );
+  });
+
+  test("getConfigurationKey works for positional argument", () => {
+    let command = getSubCommandWithPositional("blah", true, true);
+
+    expect(
+      getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
+        command.positionals![0],
+      ]),
+    ).toBeUndefined();
+
+    command = getSubCommandWithPositional(
+      "blah",
+      true,
+      false,
+      ArgumentValueTypeName.BOOLEAN,
+      true,
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
+        command.positionals![0],
+      ]),
+    ).toEqual(
+      "FOO_BLAH_FOO",
+    );
+
+    command = getSubCommandWithPositional(
+      "blah",
+      true,
+      true,
+      ArgumentValueTypeName.BOOLEAN,
+      true,
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
+        command.positionals![0],
+      ]),
+    ).toEqual(
+      "FOO_BLAH_FOO[_<index>]",
+    );
+
+    command = getSubCommandWithPositional(
+      "blah",
+      true,
+      true,
+      ArgumentValueTypeName.BOOLEAN,
+      true,
+      "FOO_BAR",
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(getCLIConfig(), command, [
+        command.positionals![0],
+      ]),
+    ).toEqual(
+      "FOO_BAR[_<index>]",
+    );
+  });
+
+  test("getConfigurationKey works for simple option argument", () => {
+    let command = getSubCommandWithOption("blah", true, false, true);
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [command.options![0] as Option],
+      ),
+    ).toBeUndefined();
+
+    command = getSubCommandWithOption(
+      "blah",
+      true,
+      false,
+      false,
+      ArgumentValueTypeName.BOOLEAN,
+      undefined,
+      true,
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [command.options![0] as Option],
+      ),
+    ).toEqual(
+      "FOO_BLAH_FOO",
+    );
+
+    command = getSubCommandWithOption(
+      "blah",
+      true,
+      false,
+      true,
+      ArgumentValueTypeName.BOOLEAN,
+      undefined,
+      true,
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [command.options![0] as Option],
+      ),
+    ).toEqual(
+      "FOO_BLAH_FOO[_<index>]",
+    );
+
+    command = getSubCommandWithOption(
+      "blah",
+      true,
+      false,
+      true,
+      ArgumentValueTypeName.BOOLEAN,
+      undefined,
+      true,
+      "FOO_BAR",
+    );
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [command.options![0] as Option],
+      ),
+    ).toEqual(
+      "FOO_BAR[_<index>]",
+    );
+  });
+
+  test("getConfigurationKey works for complex option argument", () => {
+    let command = getSubCommandWithComplexOptions();
+
+    let arg0 = command.options![0] as ComplexOption;
+    let arg1 = arg0.properties[0] as ComplexOption;
+    let arg2 = arg1.properties[0] as Option;
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [
+          arg0 as unknown as SubCommandArgument,
+          arg1 as unknown as SubCommandArgument,
+          arg2 as unknown as SubCommandArgument,
+        ],
+      ),
+    ).toBeUndefined();
+
+    command = getSubCommandWithComplexOptions(true, true);
+
+    arg0 = command.options![0] as ComplexOption;
+    arg1 = arg0.properties[0] as ComplexOption;
+    arg2 = arg1.properties[0] as Option;
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [
+          arg0 as unknown as SubCommandArgument,
+          arg1 as unknown as SubCommandArgument,
+          arg2 as unknown as SubCommandArgument,
+        ],
+      ),
+    ).toEqual(
+      "FOO_SUBCOMMAND_ALPHA[_<index>]_BETA[_<index>]_GAMMA",
+    );
+
+    arg2 = arg1.properties[1] as Option;
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [
+          arg0 as unknown as SubCommandArgument,
+          arg1 as unknown as SubCommandArgument,
+          arg2 as unknown as SubCommandArgument,
+        ],
+      ),
+    ).toEqual(
+      "FOO_SUBCOMMAND_ALPHA[_<index>]_BETA[_<index>]_DELTA[_<index>]",
+    );
+
+    arg0 = command.options![1] as ComplexOption;
+    arg1 = arg0.properties[0] as ComplexOption;
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [
+          arg0 as unknown as SubCommandArgument,
+          arg1 as unknown as SubCommandArgument,
+        ],
+      ),
+    ).toEqual(
+      "FOO_SUBCOMMAND_EPSILON_FOO_BAR_A",
+    );
+
+    command = getSubCommandWithComplexOptions(true, true, true);
+
+    arg0 = command.options![1] as ComplexOption;
+    arg1 = arg0.properties[1] as ComplexOption;
+
+    expect(
+      getSubCommandArgumentConfigurationKey(
+        getCLIConfig(),
+        command,
+        [
+          arg0 as unknown as SubCommandArgument,
+          arg1 as unknown as SubCommandArgument,
+        ],
+      ),
+    ).toEqual(
+      "FOO_SUBCOMMAND_EPSILON_FOO_BAR_B[_<index>]",
+    );
+  });
+});