@flowscripter/dynamic-cli-framework 1.1.5 → 1.2.0

package/tests/runtime/values/argumentValueValidation.test.ts

@@ -286,7 +286,7 @@ describe("argumentValueValidation tests", () => {
     }]);
   });
 
-  test("Invalid option argument value", () => {
+  test("Invalid option argument value - not an allowable value", () => {
     let option: Option = {
       name: "foo",
       type: ArgumentValueTypeName.STRING,
@@ -312,6 +312,27 @@ describe("argumentValueValidation tests", () => {
     }]);
   });
 
+  test("Invalid option argument value - not within range", () => {
+    const option: Option = {
+      name: "foo",
+      type: ArgumentValueTypeName.INTEGER,
+      minValueInclusive: 1,
+    };
+    const invalidArguments: Array<InvalidArgument> = [];
+    expect(validateOptionValue(option, "1", invalidArguments), "1");
+    expect(invalidArguments).toEqual([]);
+
+    expect(
+      validateOptionValue(option, "0", invalidArguments),
+    ).toBeUndefined();
+    expect(invalidArguments).toEqual([{
+      argument: option,
+      name: "foo",
+      value: "0",
+      reason: InvalidArgumentReason.ILLEGAL_VALUE,
+    }]);
+  });
+
   test("Complex options", () => {
     const option: ComplexOption = {
       name: "foo",
@@ -973,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();
+  });
+});