cli-kiss 0.2.3 → 0.2.5

package/tests/unit.command.usage.ts

@@ -12,9 +12,10 @@ import {
   positionalRequired,
   positionalVariadics,
   ReaderArgs,
+  type,
+  typeChoice,
   typeList,
   typeNumber,
-  typeString,
   typeTuple,
   TypoSupport,
   usageToStyledLines,
@@ -34,6 +35,13 @@ const rootCommand = commandChained<any, any, any>(
   operation(
     {
       options: {
+        choiceOption: optionSingleValue({
+          long: "choice-option",
+          type: typeChoice("choice", ["unset", "empty", "choice1", "choice2"]),
+          description: "choice-option description",
+          defaultWhenNotInlined: () => "empty",
+          defaultWhenNotDefined: () => "unset",
+        }),
         booleanFlag: optionFlag({
           short: "b",
           long: "boolean-flag",
@@ -42,13 +50,12 @@ const rootCommand = commandChained<any, any, any>(
       },
       positionals: [
         positionalRequired({
-          label: "POS-1",
           description: "Required positional number 1",
-          type: typeNumber,
+          type: typeNumber("pos-1"),
         }),
       ],
     },
-    async (context, inputs) => {
+    async function (context, inputs) {
       return { at: "root", context, inputs };
     },
   ),
@@ -73,26 +80,24 @@ const rootCommand = commandChained<any, any, any>(
           stringOption: optionSingleValue({
             short: "s",
             long: "string-option",
-            type: typeString,
-            default: () => undefined,
-            label: "COOL-STUFF",
+            type: type("cool-stuff"),
+            defaultWhenNotDefined: () => undefined,
             description: "string-option description",
           }),
           complexOption: optionRepeatable({
             long: "complex-option",
-            type: typeTuple([typeNumber, typeList(typeString)]),
+            type: typeTuple([typeNumber(), typeList(type("string"))]),
             description: "complex-option description",
           }),
         },
         positionals: [
           positionalRequired({
-            label: "POS-2",
             description: "Required positional number 2",
-            type: typeNumber,
+            type: typeNumber("pos-2"),
           }),
         ],
       },
-      async (context, inputs) => {
+      async function (context, inputs) {
         return { at: "root", context, inputs };
       },
     ),
@@ -122,13 +127,12 @@ const rootCommand = commandChained<any, any, any>(
             options: {},
             positionals: [
               positionalRequired({
-                label: "POS-STRING",
                 description: "Required positional string",
-                type: typeString,
+                type: type("pos-3.1"),
               }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub1", context, inputs };
           },
         ),
@@ -148,7 +152,17 @@ const rootCommand = commandChained<any, any, any>(
                 { positional: "40" },
                 { positional: "41" },
                 { subcommand: "sub2" },
-                { option: { long: "dudu", value: "hello" } },
+                { option: { long: "dudu", inlined: "hello" } },
+                { positional: "50" },
+              ],
+            },
+            {
+              explanation: "Example usage of subcommand 2",
+              commandArgs: [
+                { positional: "40" },
+                { positional: "41" },
+                { subcommand: "sub2" },
+                { option: { long: "dudu", separated: ["hello"] } },
                 { positional: "50" },
               ],
             },
@@ -159,33 +173,30 @@ const rootCommand = commandChained<any, any, any>(
             options: {
               duduValue: optionSingleValue({
                 long: "dudu",
-                type: typeString,
-                default: () => "duduDefault",
+                type: type("dudu-value"),
+                defaultWhenNotDefined: () => "duduDefault",
                 hint: "Dudu option hint",
                 description: "Dudu option description",
               }),
             },
             positionals: [
               positionalRequired({
-                label: "POS-NUMBER",
                 description: "Required positional number",
-                type: typeNumber,
+                type: typeNumber("pos-3.2"),
               }),
               positionalOptional({
-                label: "OPT-POS",
                 description: "Optional positional string",
                 hint: "Optional positional hint",
-                type: typeString,
+                type: type("pos-4"),
                 default: () => "42",
               }),
               positionalVariadics({
-                label: "VARIADIC",
                 description: "Variadic positionals strings",
-                type: typeString,
+                type: type("pos-5"),
               }),
             ],
           },
-          async (context, inputs) => {
+          async function (context, inputs) {
             return { at: "sub2", context, inputs };
           },
         ),
@@ -194,7 +205,7 @@ const rootCommand = commandChained<any, any, any>(
   ),
 );
 
-it("run", async () => {
+it("run", async function () {
   const usage1 = await getUsage([], rootCommand);
   const usage2 = await getUsage(["50"], rootCommand);
   const usage3 = await getUsage(["50", "51"], rootCommand);
@@ -209,107 +220,113 @@ it("run", async () => {
     rootCommand,
   );
 
-  console.log(usage1.join("\n"));
-  console.log(usage2.join("\n"));
-  console.log(usage3.join("\n"));
-  console.log(usage4.join("\n"));
-  console.log(usage5.join("\n"));
-  console.log(usage6.join("\n"));
-  console.log(usage7.join("\n"));
-  /*
-   */
-
   const usageRoot = [
-    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{[REST]...}@darkBlue}+",
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<pos-1>}@darkBlue}+ {{[REST]...}@darkBlue}+",
     "",
     "{Root command description}+",
     "{{Root command details.}-}*",
     "{{Root second line of command details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
-    "  {{<POS-1>}@darkBlue}+  Required positional number 1",
+    "  {{<pos-1>}@darkBlue}+  Required positional number 1",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*  boolean-flag description",
+    "      {{--choice-option}@darkCyan}+ {{<choice>}@darkBlue}+  choice-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*       boolean-flag description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of the root command}-}*",
-    "  {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+",
+    " {{# Example usage of the root command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+",
     "",
   ];
   const usageMid = [
-    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{<SUBCOMMAND>}@darkBlue}+",
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<pos-1>}@darkBlue}+ {{<pos-2>}@darkBlue}+ {{<subcommand>}@darkBlue}+",
     "",
     "{Mid command description}+",
     "{{Mid command details.}-}*",
     "{{Mid second line of command details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
-    "  {{<POS-1>}@darkBlue}+  Required positional number 1",
-    "  {{<POS-2>}@darkBlue}+  Required positional number 2",
+    "  {{<pos-1>}@darkBlue}+  Required positional number 1",
+    "  {{<pos-2>}@darkBlue}+  Required positional number 2",
     "",
     "{{Subcommands:}@darkGreen}+",
     "  {{sub1}@darkCyan}+  Subcommand 1 description",
     "  {{sub2}@darkCyan}+  Subcommand 2 description {{(Subcommand 2 hint)}-}*",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
+    "      {{--choice-option}@darkCyan}+ {{<choice>}@darkBlue}+                          choice-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<cool-stuff>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<number,string[,string]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of the mid command}-}*",
-    "  {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+ {{43}@darkBlue}+",
+    " {{# Example usage of the mid command}-}*",
+    " {{my-cli}@darkCyan}+ {{42}@darkBlue}+ {{-b}@darkCyan}+ {{43}@darkBlue}+",
     "",
   ];
   const usageSub1 = [
-    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{sub1}@darkCyan}+ {{<POS-STRING>}@darkBlue}+",
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<pos-1>}@darkBlue}+ {{<pos-2>}@darkBlue}+ {{sub1}@darkCyan}+ {{<pos-3.1>}@darkBlue}+",
     "",
     "{Subcommand 1 description}+",
     "{{Subcommand 1 details.}-}*",
     "{{Subcommand 1 second line of details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
-    "  {{<POS-1>}@darkBlue}+       Required positional number 1",
-    "  {{<POS-2>}@darkBlue}+       Required positional number 2",
-    "  {{<POS-STRING>}@darkBlue}+  Required positional string",
+    "  {{<pos-1>}@darkBlue}+    Required positional number 1",
+    "  {{<pos-2>}@darkBlue}+    Required positional number 2",
+    "  {{<pos-3.1>}@darkBlue}+  Required positional string",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
+    "      {{--choice-option}@darkCyan}+ {{<choice>}@darkBlue}+                          choice-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<cool-stuff>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<number,string[,string]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of subcommand 1}-}*",
-    "  {{my-cli}@darkCyan}+ {{-b}@darkCyan}+ {{42}@darkBlue}+ {{43}@darkBlue}+ {{sub1}@darkCyan}+ {{valid}@darkBlue}+",
+    " {{# Example usage of subcommand 1}-}*",
+    " {{my-cli}@darkCyan}+ {{-b}@darkCyan}+ {{42}@darkBlue}+ {{43}@darkBlue}+ {{sub1}@darkCyan}+ {{valid}@darkBlue}+",
     "",
   ];
   const usageSub2 = [
-    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<POS-1>}@darkBlue}+ {{<POS-2>}@darkBlue}+ {{sub2}@darkCyan}+ {{<POS-NUMBER>}@darkBlue}+ {{[OPT-POS]}@darkBlue}+ {{[VARIADIC]...}@darkBlue}+",
+    "{{Usage:}@darkMagenta}+ {{my-cli}@darkCyan}+ {{<pos-1>}@darkBlue}+ {{<pos-2>}@darkBlue}+ {{sub2}@darkCyan}+ {{<pos-3.2>}@darkBlue}+ {{[pos-4]}@darkBlue}+ {{[pos-5]...}@darkBlue}+",
     "",
     "{Subcommand 2 description}+ {{(Subcommand 2 hint)}-}*",
     "{{Subcommand 2 details.}-}*",
     "{{Subcommand 2 second line of details.}-}*",
     "",
     "{{Positionals:}@darkGreen}+",
-    "  {{<POS-1>}@darkBlue}+        Required positional number 1",
-    "  {{<POS-2>}@darkBlue}+        Required positional number 2",
-    "  {{<POS-NUMBER>}@darkBlue}+   Required positional number",
-    "  {{[OPT-POS]}@darkBlue}+      Optional positional string {{(Optional positional hint)}-}*",
-    "  {{[VARIADIC]...}@darkBlue}+  Variadic positionals strings",
+    "  {{<pos-1>}@darkBlue}+     Required positional number 1",
+    "  {{<pos-2>}@darkBlue}+     Required positional number 2",
+    "  {{<pos-3.2>}@darkBlue}+   Required positional number",
+    "  {{[pos-4]}@darkBlue}+     Optional positional string {{(Optional positional hint)}-}*",
+    "  {{[pos-5]...}@darkBlue}+  Variadic positionals strings",
     "",
     "{{Options:}@darkGreen}+",
-    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                           boolean-flag description",
-    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<COOL-STUFF>}@darkBlue}+                  string-option description",
-    "      {{--complex-option}@darkCyan}+ {{<NUMBER,STRING[,STRING]...>}@darkBlue}+  complex-option description",
-    "      {{--dudu}@darkCyan}+ {{<STRING>}@darkBlue}+                               Dudu option description {{(Dudu option hint)}-}*",
+    "      {{--choice-option}@darkCyan}+ {{<choice>}@darkBlue}+                          choice-option description",
+    "  {{-b}@darkCyan}+, {{--boolean-flag}@darkCyan}+{{[=no]}-}*                               boolean-flag description",
+    "  {{-s}@darkCyan}+, {{--string-option}@darkCyan}+ {{<cool-stuff>}@darkBlue}+                      string-option description",
+    "      {{--complex-option}@darkCyan}+ {{<number,string[,string]...>}@darkBlue}+{{ [*]}-}*  complex-option description",
+    "      {{--dudu}@darkCyan}+ {{<dudu-value>}@darkBlue}+                               Dudu option description {{(Dudu option hint)}-}*",
     "",
     "{{Examples:}@darkGreen}+",
-    "  {{# Example usage of subcommand 2}-}*",
-    "  {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+{{=}-}*{{hello}@darkBlue}+ {{50}@darkBlue}+",
+    " {{# Example usage of subcommand 2}-}*",
+    " {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+{{=}-}*{{hello}@darkBlue}+ {{50}@darkBlue}+",
+    " {{# Example usage of subcommand 2}-}*",
+    " {{my-cli}@darkCyan}+ {{40}@darkBlue}+ {{41}@darkBlue}+ {{sub2}@darkCyan}+ {{--dudu}@darkCyan}+ {{hello}@darkBlue}+ {{50}@darkBlue}+",
     "",
   ];
 
+  /*
+  console.log(usage1.join("\n"));
+  console.log(usage2.join("\n"));
+  console.log(usage3.join("\n"));
+  console.log(usage4.join("\n"));
+  console.log(usage5.join("\n"));
+  console.log(usage6.join("\n"));
+  console.log(usage7.join("\n"));
+   */
+
   expect(usage1).toStrictEqual(usageRoot);
   expect(usage2).toStrictEqual(usageMid);
   expect(usage3).toStrictEqual(usageMid);
@@ -325,20 +342,9 @@ async function getUsage<Context, Result>(
 ) {
   const readerArgs = new ReaderArgs(args);
   const commandDecoder = command.consumeAndMakeDecoder(readerArgs);
-  /*
-  try {
-    const interpreter = commandDecoder.decodeAndMakeInterpreter();
-    const result = await interpreter.executeWithContext(
-      "" as unknown as Context,
-    );
-    console.log(result);
-  } catch (error) {
-    console.log(TypoSupport.tty().computeStyledErrorMessage(error));
-  }
-    */
   return usageToStyledLines({
     cliName: "my-cli",
-    commandUsage: commandDecoder.generateUsage(),
-    typoSupport: TypoSupport.tty(),
+    usage: commandDecoder.generateUsage(),
+    typoSupport: TypoSupport.mock(),
   });
 }

package/tests/unit.runner.colors.ts

@@ -0,0 +1,197 @@
+import { it } from "@jest/globals";
+import {
+  command,
+  operation,
+  optionRepeatable,
+  positionalVariadics,
+  runAndExit,
+  type,
+  TypoSupport,
+  usageToStyledLines,
+} from "../src";
+
+const cliName = "my-cli";
+
+it("run", async function () {
+  const usage = {
+    segments: [{ positional: "[string]..." }],
+    information: { description: "Description" },
+    subcommands: [],
+    options: [{ long: "option", label: "<string>", annotation: " [*]" }],
+    positionals: [{ label: "[string]...", description: "Variadics" }],
+  };
+  const usageNone = usageToStyledLines({
+    cliName,
+    usage,
+    typoSupport: TypoSupport.none(),
+  }).join("\n");
+  const usageMock = usageToStyledLines({
+    cliName,
+    usage,
+    typoSupport: TypoSupport.mock(),
+  }).join("\n");
+  const usageTty = usageToStyledLines({
+    cliName,
+    usage,
+    typoSupport: TypoSupport.tty(),
+  }).join("\n");
+
+  await testCase("flag", ["--color=auto", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--help"], [usageTty], [], 0);
+  await testCase("env", ["--help"], [usageTty], [], 0);
+  await testCase("always", ["--help"], [usageTty], [], 0);
+  await testCase("never", ["--help"], [usageNone], [], 0);
+  await testCase("mock", ["--help"], [usageMock], [], 0);
+
+  process.env["NO_COLOR"] = "";
+  await testCase("flag", ["--color=auto", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--help"], [usageNone], [], 0);
+  await testCase("env", ["--help"], [usageNone], [], 0);
+  await testCase("always", ["--help"], [usageTty], [], 0);
+  await testCase("never", ["--help"], [usageNone], [], 0);
+  await testCase("mock", ["--help"], [usageMock], [], 0);
+  delete process.env["NO_COLOR"];
+
+  process.env["FORCE_COLOR"] = "";
+  await testCase("flag", ["--color=auto", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--help"], [usageTty], [], 0);
+  await testCase("env", ["--help"], [usageTty], [], 0);
+  await testCase("always", ["--help"], [usageTty], [], 0);
+  await testCase("never", ["--help"], [usageNone], [], 0);
+  await testCase("mock", ["--help"], [usageMock], [], 0);
+  delete process.env["FORCE_COLOR"];
+
+  process.env["FORCE_COLOR"] = "0";
+  await testCase("flag", ["--color=auto", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--help"], [usageNone], [], 0);
+  await testCase("env", ["--help"], [usageNone], [], 0);
+  await testCase("always", ["--help"], [usageTty], [], 0);
+  await testCase("never", ["--help"], [usageNone], [], 0);
+  await testCase("mock", ["--help"], [usageMock], [], 0);
+  delete process.env["FORCE_COLOR"];
+
+  process.env["MOCK_COLOR"] = "";
+  await testCase("flag", ["--color=auto", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--color=always", "--help"], [usageTty], [], 0);
+  await testCase("flag", ["--color=never", "--help"], [usageNone], [], 0);
+  await testCase("flag", ["--color=mock", "--help"], [usageMock], [], 0);
+  await testCase("flag", ["--help"], [usageMock], [], 0);
+  await testCase("env", ["--help"], [usageMock], [], 0);
+  await testCase("always", ["--help"], [usageTty], [], 0);
+  await testCase("never", ["--help"], [usageNone], [], 0);
+  await testCase("mock", ["--help"], [usageMock], [], 0);
+  delete process.env["MOCK_COLOR"];
+
+  process.env["MOCK_COLOR"] = "";
+  await testCase(
+    "flag",
+    ["--color=42"],
+    [],
+    [
+      usageMock,
+      '{{Error:}@darkRed}+ {{--color}@darkCyan}+: {{<color-mode>}@darkBlue}+: Invalid value: {{"42"}@darkYellow}+ (expected one of: {{"auto"}@darkYellow}+ | {{"always"}@darkYellow}+ | {{"never"}@darkYellow}+...)',
+    ],
+    1,
+  );
+  delete process.env["MOCK_COLOR"];
+
+  const unexpected1 = "Error: Unexpected unknown option: --color";
+  await testCase("never", ["--color=auto"], [], [usageNone, unexpected1], 1);
+  await testCase("never", ["--color=always"], [], [usageNone, unexpected1], 1);
+  await testCase("never", ["--color=never"], [], [usageNone, unexpected1], 1);
+  await testCase("never", ["--color=mock"], [], [usageNone, unexpected1], 1);
+  process.env["FORCE_COLOR"] = "0";
+  await testCase("env", ["--color=auto"], [], [usageNone, unexpected1], 1);
+  await testCase("env", ["--color=always"], [], [usageNone, unexpected1], 1);
+  await testCase("env", ["--color=never"], [], [usageNone, unexpected1], 1);
+  await testCase("env", ["--color=mock"], [], [usageNone, unexpected1], 1);
+  delete process.env["FORCE_COLOR"];
+
+  const unexpected2 =
+    "{{Error:}@darkRed}+ Unexpected unknown option: {{--color}@darkYellow}+";
+  await testCase("mock", ["--color=auto"], [], [usageMock, unexpected2], 1);
+  await testCase("mock", ["--color=always"], [], [usageMock, unexpected2], 1);
+  await testCase("mock", ["--color=never"], [], [usageMock, unexpected2], 1);
+  await testCase("mock", ["--color=mock"], [], [usageMock, unexpected2], 1);
+});
+
+async function testCase(
+  colorSetup: "flag" | "env" | "always" | "never" | "mock",
+  cliArgs: Array<string>,
+  expectStdOut: Array<string>,
+  expectStdErr: Array<string>,
+  expectExit: number,
+) {
+  const onLogStdOut = makeMocked<string, void>([
+    null as unknown as void,
+    null as unknown as void,
+  ]);
+  const onLogStdErr = makeMocked<string, void>([
+    null as unknown as void,
+    null as unknown as void,
+  ]);
+  const onExit = makeMocked<number, never>([null as never]);
+  const cmd = command<null, void>(
+    { description: "Description" },
+    operation(
+      {
+        options: {
+          value: optionRepeatable({ long: "option", type: type() }),
+        },
+        positionals: [
+          positionalVariadics({ type: type(), description: "Variadics" }),
+        ],
+      },
+      async function (_, { options: { value }, positionals: [rest] }) {
+        console.log(
+          `Has executed: ${JSON.stringify(value)}, ${JSON.stringify(rest)}`,
+        );
+      },
+    ),
+  );
+  console.log = onLogStdOut.call;
+  console.error = onLogStdErr.call;
+  await runAndExit(cliName, cliArgs, null, cmd, {
+    buildVersion: "1.0.0",
+    onExit: onExit.call,
+    colorSetup,
+  });
+  expect({
+    stdOut: onLogStdOut.history,
+    stdErr: onLogStdErr.history,
+  }).toEqual({
+    stdOut: expectStdOut,
+    stdErr: expectStdErr,
+  });
+  expect(onExit.history).toEqual([expectExit]);
+}
+
+function makeMocked<P, R>(returns: Array<R>) {
+  const history = new Array<P>();
+  return {
+    history,
+    call(p: P) {
+      history.push(p);
+      if (history.length > returns.length) {
+        throw new Error(
+          `Mocked function called more times than expected. History: ${JSON.stringify(
+            history,
+          )}, returns: ${JSON.stringify(returns)}`,
+        );
+      }
+      return returns[history.length - 1]!;
+    },
+  };
+}