@flowscripter/dynamic-cli-framework 1.2.2 → 1.3.0

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

@@ -31,149 +31,195 @@ function getSubCommand(
 }
 describe("CommandValidator tests", () => {
   test("SubCommand validation fails due to duplicate argument names", () => {
-    let command = getSubCommand("command", [{
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }], []);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
 
-    command = getSubCommand("command", [{
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }], [{
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [], [{
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation fails due to duplicate argument names or short aliases", () => {
-    let command = getSubCommand("command", [{
-      name: "f",
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "foo",
-      shortAlias: "f",
-      type: ArgumentValueTypeName.STRING,
-    }], []);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [{
-      name: "foo1",
-      shortAlias: "f",
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "foo2",
-      shortAlias: "f",
-      type: ArgumentValueTypeName.STRING,
-    }], []);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo1",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "foo2",
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
-  test(
-    "SubCommand validation fails due to boolean argument type not supporting allowable values",
-    () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        allowableValues: ["goo"],
-      }], []);
+  test("SubCommand validation fails due to boolean argument type not supporting allowable values", () => {
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          allowableValues: ["goo"],
+        },
+      ],
+      [],
+    );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-    },
-  );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+  });
 
-  test(
-    "SubCommand validation fails due to boolean argument type not supporting case sensitivity",
-    () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.BOOLEAN,
-        isCaseInsensitive: true,
-      }], []);
+  test("SubCommand validation fails due to boolean argument type not supporting case sensitivity", () => {
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.BOOLEAN,
+          isCaseInsensitive: true,
+        },
+      ],
+      [],
+    );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-    },
-  );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+  });
 
-  test(
-    "SubCommand validation fails due to number argument type not supporting case insensitivity",
-    () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        isCaseInsensitive: false,
-      }], []);
-
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-    },
-  );
+  test("SubCommand validation fails due to number argument type not supporting case insensitivity", () => {
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          isCaseInsensitive: false,
+        },
+      ],
+      [],
+    );
 
-  test(
-    "SubCommand validation fails due to string argument type not supporting value range",
-    () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        minValueInclusive: 1,
-      }], []);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+  });
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-    },
-  );
+  test("SubCommand validation fails due to string argument type not supporting value range", () => {
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          minValueInclusive: 1,
+        },
+      ],
+      [],
+    );
 
-  test(
-    "SubCommand validation fails due to number argument type not supporting value range and allowable values",
-    () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.NUMBER,
-        allowableValues: [1],
-        minValueInclusive: 1,
-      }], []);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+  });
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-    },
-  );
+  test("SubCommand validation fails due to number argument type not supporting value range and allowable values", () => {
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.NUMBER,
+          allowableValues: [1],
+          minValueInclusive: 1,
+        },
+      ],
+      [],
+    );
+
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+  });
 
   test(
     "SubCommand validation fails due to option default value" +
       " not matching any values specified in argument valid values",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        defaultValue: "bar",
-        allowableValues: ["goo"],
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            type: ArgumentValueTypeName.STRING,
+            defaultValue: "bar",
+            allowableValues: ["goo"],
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -181,15 +227,20 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to option default value" +
       " not matching any values specified in argument valid values with case sensitivity",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        defaultValue: "bar",
-        allowableValues: ["BAR"],
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            type: ArgumentValueTypeName.STRING,
+            defaultValue: "bar",
+            allowableValues: ["BAR"],
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -197,13 +248,19 @@ describe("CommandValidator tests", () => {
     "SubCommand validation successed with option default value" +
       " matching value specified in argument valid values with case insensitivity",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        defaultValue: "bar",
-        allowableValues: ["BAR"],
-        isCaseInsensitive: true,
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            type: ArgumentValueTypeName.STRING,
+            defaultValue: "bar",
+            allowableValues: ["BAR"],
+            isCaseInsensitive: true,
+          },
+        ],
+        [],
+      );
 
       new CommandValidator(getCLIConfig()).validate(command);
     },
@@ -213,14 +270,19 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to the type of option defaultValue" +
       " not matching the type specified in argument type",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        defaultValue: "bar",
-        type: ArgumentValueTypeName.BOOLEAN,
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            defaultValue: "bar",
+            type: ArgumentValueTypeName.BOOLEAN,
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -228,14 +290,19 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to option defaultValue" +
       " being an array and option does not support array",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        defaultValue: ["bar1", "bar2"],
-        type: ArgumentValueTypeName.STRING,
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            defaultValue: ["bar1", "bar2"],
+            type: ArgumentValueTypeName.STRING,
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -243,128 +310,187 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to the type of values in argument" +
       " allowableValues not matching the type specified in argument type",
     () => {
-      const command = getSubCommand("command", [{
-        name: "foo",
-        defaultValue: "bar",
-        allowableValues: [1],
-        type: ArgumentValueTypeName.STRING,
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "foo",
+            defaultValue: "bar",
+            allowableValues: [1],
+            type: ArgumentValueTypeName.STRING,
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
   test("SubCommand validation fails due to invalid command name", () => {
-    const command = getSubCommand("command", [{
-      name: "-foo",
-      type: ArgumentValueTypeName.STRING,
-    }], []);
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "-foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation fails due to invalid command short alias", () => {
-    const command = getSubCommand("command", [{
-      name: "foo",
-      shortAlias: "foo",
-      type: ArgumentValueTypeName.STRING,
-    }], []);
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          shortAlias: "foo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation fails due to non-last positional being varargs", () => {
-    let command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargMultiple: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    let command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargMultiple: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargOptional: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargOptional: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation fails due to more than one positional being varargs", () => {
-    let command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargMultiple: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      isVarargMultiple: true,
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    let command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargMultiple: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          isVarargMultiple: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargOptional: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      isVarargOptional: true,
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargOptional: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          isVarargOptional: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargOptional: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      isVarargMultiple: true,
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargOptional: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          isVarargMultiple: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [], [{
-      name: "foo",
-      isVarargMultiple: true,
-      type: ArgumentValueTypeName.STRING,
-    }, {
-      name: "goo",
-      isVarargOptional: true,
-      type: ArgumentValueTypeName.STRING,
-    }]);
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [],
+      [
+        {
+          name: "foo",
+          isVarargMultiple: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+        {
+          name: "goo",
+          isVarargOptional: true,
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation succeeds", () => {
-    const command = getSubCommand("command", [{
-      name: "foo",
-      defaultValue: "bar",
-      allowableValues: ["bar", "gar"],
-      shortAlias: "f",
-      type: ArgumentValueTypeName.STRING,
-    }], [{
-      name: "boo",
-      type: ArgumentValueTypeName.NUMBER,
-      isVarargMultiple: true,
-      allowableValues: [1, 2],
-    }]);
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          defaultValue: "bar",
+          allowableValues: ["bar", "gar"],
+          shortAlias: "f",
+          type: ArgumentValueTypeName.STRING,
+        },
+      ],
+      [
+        {
+          name: "boo",
+          type: ArgumentValueTypeName.NUMBER,
+          isVarargMultiple: true,
+          allowableValues: [1, 2],
+        },
+      ],
+    );
 
     new CommandValidator(getCLIConfig()).validate(command);
   });
@@ -379,8 +505,7 @@ describe("CommandValidator tests", () => {
         allowableValues: ["goo"],
       });
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -393,8 +518,7 @@ describe("CommandValidator tests", () => {
         defaultValue: "bar",
       });
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -408,8 +532,7 @@ describe("CommandValidator tests", () => {
         type: ArgumentValueTypeName.STRING,
       });
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -418,8 +541,7 @@ describe("CommandValidator tests", () => {
       type: ArgumentValueTypeName.STRING,
     });
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("GlobalCommand validation fails due to invalid command short alias", () => {
@@ -427,8 +549,7 @@ describe("CommandValidator tests", () => {
       type: ArgumentValueTypeName.STRING,
     });
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("GlobalCommand validation succeeds with global argument", () => {
@@ -448,12 +569,9 @@ describe("CommandValidator tests", () => {
   });
 
   test("GrouoCommand validation fails due to name and member duplicate names", () => {
-    const command = getGroupCommand("command", [
-      getSubCommand("command", [], []),
-    ]);
+    const command = getGroupCommand("command", [getSubCommand("command", [], [])]);
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("GrouoCommand validation fails due to duplicate member command names", () => {
@@ -462,166 +580,215 @@ describe("CommandValidator tests", () => {
       getSubCommand("command", [], []),
     ]);
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("GrouoCommand validation fails due to invalid command name", () => {
-    const command = getGroupCommand("-group", [
-      getSubCommand("command", [], []),
-    ]);
+    const command = getGroupCommand("-group", [getSubCommand("command", [], [])]);
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("GroupCommand validation succeeds", () => {
     const command = getGroupCommand("group", [
       getSubCommand("command1", [], []),
-      getSubCommand("command2", [{
-        name: "foo",
-        defaultValue: "bar",
-        allowableValues: ["bar", "gar"],
-        shortAlias: "f",
-        type: ArgumentValueTypeName.STRING,
-      }], [{
-        name: "boo",
-        type: ArgumentValueTypeName.NUMBER,
-        isVarargMultiple: true,
-        allowableValues: [1, 2],
-      }]),
+      getSubCommand(
+        "command2",
+        [
+          {
+            name: "foo",
+            defaultValue: "bar",
+            allowableValues: ["bar", "gar"],
+            shortAlias: "f",
+            type: ArgumentValueTypeName.STRING,
+          },
+        ],
+        [
+          {
+            name: "boo",
+            type: ArgumentValueTypeName.NUMBER,
+            isVarargMultiple: true,
+            allowableValues: [1, 2],
+          },
+        ],
+      ),
     ]);
 
     new CommandValidator(getCLIConfig()).validate(command);
   });
 
   test("SubCommand validation succeeds", () => {
-    new CommandValidator(getCLIConfig()).validate(
-      getSubCommandWithComplexOptions(true),
-    );
+    new CommandValidator(getCLIConfig()).validate(getSubCommandWithComplexOptions(true));
   });
 
   test("SubCommand validation fails due to nested duplicate property paths", () => {
-    const command = getSubCommand("command", [{
-      name: "alpha",
-      shortAlias: "a",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        shortAlias: "b",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "gamma",
-          shortAlias: "g",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }, {
-      name: "alpha",
-      shortAlias: "a",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        shortAlias: "b",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "gamma",
-          shortAlias: "g",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
-
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          shortAlias: "a",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              shortAlias: "b",
+              type: ComplexValueTypeName.COMPLEX,
+              isArray: true,
+              properties: [
+                {
+                  name: "gamma",
+                  shortAlias: "g",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: "alpha",
+          shortAlias: "a",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              shortAlias: "b",
+              type: ComplexValueTypeName.COMPLEX,
+              isArray: true,
+              properties: [
+                {
+                  name: "gamma",
+                  shortAlias: "g",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
+
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test("SubCommand validation fails due to duplicate argument names or short aliases in sibling nested properties", () => {
-    const command = getSubCommand("command", [{
-      name: "alpha",
-      shortAlias: "a",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        shortAlias: "b",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "gamma",
-          shortAlias: "g",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }, {
-      name: "a",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "b",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "g",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
-
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
+    const command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          shortAlias: "a",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              shortAlias: "b",
+              type: ComplexValueTypeName.COMPLEX,
+              isArray: true,
+              properties: [
+                {
+                  name: "gamma",
+                  shortAlias: "g",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+        {
+          name: "a",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "b",
+              type: ComplexValueTypeName.COMPLEX,
+              isArray: true,
+              properties: [
+                {
+                  name: "g",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
+
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
   });
 
   test(
     "SubCommand validation fails due to nested property option default value" +
       " not matching any values specified in argument valid values",
     () => {
-      let command = getSubCommand("command", [{
-        name: "alpha",
-        shortAlias: "a",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "beta",
-          shortAlias: "b",
-          type: ComplexValueTypeName.COMPLEX,
-          isArray: true,
-          properties: [{
-            name: "gamma",
-            shortAlias: "g",
-            type: ArgumentValueTypeName.STRING,
-            allowableValues: ["foo"],
-            defaultValue: "bar",
-          }],
-        }],
-      }], []);
-
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-
-      command = getSubCommand("command", [{
-        name: "alpha",
-        shortAlias: "a",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "beta",
-          shortAlias: "b",
-          type: ComplexValueTypeName.COMPLEX,
-          isArray: true,
-          properties: [{
-            name: "gamma",
-            shortAlias: "g",
-            type: ArgumentValueTypeName.STRING,
-            allowableValues: ["foo", "bar"],
-            defaultValue: "bar",
-          }],
-        }],
-      }], []);
+      let command = getSubCommand(
+        "command",
+        [
+          {
+            name: "alpha",
+            shortAlias: "a",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            properties: [
+              {
+                name: "beta",
+                shortAlias: "b",
+                type: ComplexValueTypeName.COMPLEX,
+                isArray: true,
+                properties: [
+                  {
+                    name: "gamma",
+                    shortAlias: "g",
+                    type: ArgumentValueTypeName.STRING,
+                    allowableValues: ["foo"],
+                    defaultValue: "bar",
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [],
+      );
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+
+      command = getSubCommand(
+        "command",
+        [
+          {
+            name: "alpha",
+            shortAlias: "a",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            properties: [
+              {
+                name: "beta",
+                shortAlias: "b",
+                type: ComplexValueTypeName.COMPLEX,
+                isArray: true,
+                properties: [
+                  {
+                    name: "gamma",
+                    shortAlias: "g",
+                    type: ArgumentValueTypeName.STRING,
+                    allowableValues: ["foo", "bar"],
+                    defaultValue: "bar",
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [],
+      );
       new CommandValidator(getCLIConfig()).validate(command);
     },
   );
@@ -630,27 +797,36 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to the type of nested property complex option defaultValue" +
       " not matching the type specified in argument type",
     () => {
-      const command = getSubCommand("command", [{
-        name: "alpha",
-        shortAlias: "a",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "beta",
-          shortAlias: "b",
-          type: ComplexValueTypeName.COMPLEX,
-          isArray: true,
-          properties: [{
-            name: "gamma",
-            shortAlias: "g",
-            type: ArgumentValueTypeName.BOOLEAN,
-            defaultValue: 1,
-          }],
-        }],
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "alpha",
+            shortAlias: "a",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            properties: [
+              {
+                name: "beta",
+                shortAlias: "b",
+                type: ComplexValueTypeName.COMPLEX,
+                isArray: true,
+                properties: [
+                  {
+                    name: "gamma",
+                    shortAlias: "g",
+                    type: ArgumentValueTypeName.BOOLEAN,
+                    defaultValue: 1,
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -658,27 +834,36 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to nested property complex option defaultValue" +
       " being an array and option does not support array",
     () => {
-      const command = getSubCommand("command", [{
-        name: "alpha",
-        shortAlias: "a",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        properties: [{
-          name: "beta",
-          shortAlias: "b",
-          type: ComplexValueTypeName.COMPLEX,
-          isArray: true,
-          properties: [{
-            name: "gamma",
-            shortAlias: "g",
-            type: ArgumentValueTypeName.STRING,
-            defaultValue: ["foo", "bar"],
-          }],
-        }],
-      }], []);
+      const command = getSubCommand(
+        "command",
+        [
+          {
+            name: "alpha",
+            shortAlias: "a",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            properties: [
+              {
+                name: "beta",
+                shortAlias: "b",
+                type: ComplexValueTypeName.COMPLEX,
+                isArray: true,
+                properties: [
+                  {
+                    name: "gamma",
+                    shortAlias: "g",
+                    type: ArgumentValueTypeName.STRING,
+                    defaultValue: ["foo", "bar"],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+        [],
+      );
 
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
     },
   );
 
@@ -686,167 +871,240 @@ describe("CommandValidator tests", () => {
     "SubCommand validation fails due to the type of nested property values in complex option" +
       " allowableValues not matching the type specified in argument type",
     () => {
-      let command = getSubCommand("command", [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        defaultValue: [
+      let command = getSubCommand(
+        "command",
+        [
           {
-            beta: 1,
+            name: "alpha",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            defaultValue: [
+              {
+                beta: 1,
+              },
+            ],
+            properties: [
+              {
+                name: "beta",
+                type: ComplexValueTypeName.COMPLEX,
+                properties: [
+                  {
+                    name: "gamma",
+                    type: ArgumentValueTypeName.BOOLEAN,
+                  },
+                ],
+              },
+            ],
           },
         ],
-        properties: [{
-          name: "beta",
-          type: ComplexValueTypeName.COMPLEX,
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.BOOLEAN,
-          }],
-        }],
-      }], []);
-
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-
-      command = getSubCommand("command", [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        defaultValue: [
+        [],
+      );
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+
+      command = getSubCommand(
+        "command",
+        [
           {
-            beta: {
-              gamma: 1,
-            },
+            name: "alpha",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            defaultValue: [
+              {
+                beta: {
+                  gamma: 1,
+                },
+              },
+            ],
+            properties: [
+              {
+                name: "beta",
+                type: ComplexValueTypeName.COMPLEX,
+                properties: [
+                  {
+                    name: "gamma",
+                    type: ArgumentValueTypeName.BOOLEAN,
+                  },
+                ],
+              },
+            ],
           },
         ],
-        properties: [{
-          name: "beta",
-          type: ComplexValueTypeName.COMPLEX,
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.BOOLEAN,
-          }],
-        }],
-      }], []);
-
-      expect(() => new CommandValidator(getCLIConfig()).validate(command))
-        .toThrow();
-
-      command = getSubCommand("command", [{
-        name: "alpha",
-        type: ComplexValueTypeName.COMPLEX,
-        isArray: true,
-        defaultValue: [
+        [],
+      );
+
+      expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+
+      command = getSubCommand(
+        "command",
+        [
           {
-            beta: {
-              gamma: "foo",
-            },
+            name: "alpha",
+            type: ComplexValueTypeName.COMPLEX,
+            isArray: true,
+            defaultValue: [
+              {
+                beta: {
+                  gamma: "foo",
+                },
+              },
+            ],
+            properties: [
+              {
+                name: "beta",
+                type: ComplexValueTypeName.COMPLEX,
+                properties: [
+                  {
+                    name: "gamma",
+                    type: ArgumentValueTypeName.STRING,
+                  },
+                ],
+              },
+            ],
           },
         ],
-        properties: [{
-          name: "beta",
-          type: ComplexValueTypeName.COMPLEX,
-          properties: [{
-            name: "gamma",
-            type: ArgumentValueTypeName.STRING,
-          }],
-        }],
-      }], []);
+        [],
+      );
 
       new CommandValidator(getCLIConfig()).validate(command);
     },
   );
 
   test("SubCommand validation fails due to invalid complex option property name", () => {
-    let command = getSubCommand("command", [{
-      name: "alpha",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "-beta",
-        type: ComplexValueTypeName.COMPLEX,
-        properties: [{
-          name: "gamma",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
-
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-    command = getSubCommand("command", [{
-      name: "alpha",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        type: ComplexValueTypeName.COMPLEX,
-        properties: [{
-          name: "gamma",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "-beta",
+              type: ComplexValueTypeName.COMPLEX,
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
+
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+    command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              type: ComplexValueTypeName.COMPLEX,
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
 
     new CommandValidator(getCLIConfig()).validate(command);
   });
 
   test("SubCommand validation fails due to invalid complex option property short alias", () => {
-    let command = getSubCommand("command", [{
-      name: "alpha",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        shortAlias: "-",
-        type: ComplexValueTypeName.COMPLEX,
-        properties: [{
-          name: "gamma",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
-
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrow();
-
-    command = getSubCommand("command", [{
-      name: "alpha",
-      type: ComplexValueTypeName.COMPLEX,
-      isArray: true,
-      properties: [{
-        name: "beta",
-        shortAlias: "b",
-        type: ComplexValueTypeName.COMPLEX,
-        properties: [{
-          name: "gamma",
-          type: ArgumentValueTypeName.STRING,
-        }],
-      }],
-    }], []);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              shortAlias: "-",
+              type: ComplexValueTypeName.COMPLEX,
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
+
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrow();
+
+    command = getSubCommand(
+      "command",
+      [
+        {
+          name: "alpha",
+          type: ComplexValueTypeName.COMPLEX,
+          isArray: true,
+          properties: [
+            {
+              name: "beta",
+              shortAlias: "b",
+              type: ComplexValueTypeName.COMPLEX,
+              properties: [
+                {
+                  name: "gamma",
+                  type: ArgumentValueTypeName.STRING,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+      [],
+    );
 
     new CommandValidator(getCLIConfig()).validate(command);
   });
 
   test("SubCommand validation fails due to custom configuration key when not enabled", () => {
-    let command = getSubCommand("command", [{
-      name: "foo",
-      type: ArgumentValueTypeName.STRING,
-      configurationKey: "FOO_BAR",
-    }], []);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR",
+        },
+      ],
+      [],
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrowError(
-        "Command: 'command' enableConfiguration is false, but an argument defines a configurationKey: 'FOO_BAR'",
-      );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrowError(
+      "Command: 'command' enableConfiguration is false, but an argument defines a configurationKey: 'FOO_BAR'",
+    );
 
     command = getSubCommand(
       "command",
-      [{
-        name: "foo",
-        type: ArgumentValueTypeName.STRING,
-        configurationKey: "FOO_BAR",
-      }],
+      [
+        {
+          name: "foo",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR",
+        },
+      ],
       [],
       true,
     );
@@ -855,30 +1113,47 @@ describe("CommandValidator tests", () => {
   });
 
   test("SubCommand validation fails due to duplicate custom configuration key", () => {
-    let command = getSubCommand("command", [{
-      name: "foo1",
-      type: ArgumentValueTypeName.STRING,
-      configurationKey: "FOO_BAR",
-    }], [{
-      name: "foo2",
-      type: ArgumentValueTypeName.STRING,
-      configurationKey: "FOO_BAR",
-    }], true);
+    let command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR",
+        },
+      ],
+      [
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR",
+        },
+      ],
+      true,
+    );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrowError(
-        "Command: 'command' contains arguments with the same configuration key: 'FOO_BAR'",
-      );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrowError(
+      "Command: 'command' contains arguments with the same configuration key: 'FOO_BAR'",
+    );
 
-    command = getSubCommand("command", [{
-      name: "foo1",
-      type: ArgumentValueTypeName.STRING,
-      configurationKey: "FOO_BAR_1",
-    }], [{
-      name: "foo2",
-      type: ArgumentValueTypeName.STRING,
-      configurationKey: "FOO_BAR_2",
-    }], true);
+    command = getSubCommand(
+      "command",
+      [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR_1",
+        },
+      ],
+      [
+        {
+          name: "foo2",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "FOO_BAR_2",
+        },
+      ],
+      true,
+    );
 
     new CommandValidator(getCLIConfig()).validate(command);
   });
@@ -886,34 +1161,36 @@ describe("CommandValidator tests", () => {
   test("SubCommand validation fails due to invalid configuration key", () => {
     let command = getSubCommand(
       "command",
-      [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-        configurationKey: "-FOO_BAR",
-      }],
+      [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "-FOO_BAR",
+        },
+      ],
       [],
       true,
     );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrowError(
-        "Illegal configuration key: '-FOO_BAR'",
-      );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrowError(
+      "Illegal configuration key: '-FOO_BAR'",
+    );
 
     command = getSubCommand(
       "command",
-      [{
-        name: "foo1",
-        type: ArgumentValueTypeName.STRING,
-        configurationKey: "3_FOO_BAR_1",
-      }],
+      [
+        {
+          name: "foo1",
+          type: ArgumentValueTypeName.STRING,
+          configurationKey: "3_FOO_BAR_1",
+        },
+      ],
       [],
       true,
     );
 
-    expect(() => new CommandValidator(getCLIConfig()).validate(command))
-      .toThrowError(
-        "Illegal configuration key: '3_FOO_BAR_1'",
-      );
+    expect(() => new CommandValidator(getCLIConfig()).validate(command)).toThrowError(
+      "Illegal configuration key: '3_FOO_BAR_1'",
+    );
   });
 });