fix: error handling for unexpected numeric arguments passed to cli

lib/cli/options.js

@@ -10,15 +10,25 @@
 const fs = require('fs');
 const ansi = require('ansi-colors');
 const yargsParser = require('yargs-parser');
-const {types, aliases} = require('./run-option-metadata');
+const {
+  types,
+  aliases,
+  isMochaFlag,
+  expectedTypeForFlag
+} = require('./run-option-metadata');
 const {ONE_AND_DONE_ARGS} = require('./one-and-dones');
 const mocharc = require('../mocharc.json');
 const {list} = require('./run-helpers');
 const {loadConfig, findConfig} = require('./config');
 const findUp = require('find-up');
 const debug = require('debug')('mocha:cli:options');
 const {isNodeFlag} = require('./node-flags');
-const {createUnparsableFileError} = require('../errors');
+const {
+  createUnparsableFileError,
+  createInvalidArgumentTypeError,
+  createUnsupportedError
+} = require('../errors');
+const {isNumeric} = require('../utils');
 
 /**
  * The `yargs-parser` namespace
@@ -104,24 +114,41 @@ const nargOpts = types.array
 const parse = (args = [], defaultValues = {}, ...configObjects) => {
   // save node-specific args for special handling.
   // 1. when these args have a "=" they should be considered to have values
-  // 2. if they don't, they just boolean flags
+  // 2. if they don't, they are just boolean flags
   // 3. to avoid explicitly defining the set of them, we tell yargs-parser they
   //    are ALL boolean flags.
   // 4. we can then reapply the values after yargs-parser is done.
-  const nodeArgs = (Array.isArray(args) ? args : args.split(' ')).reduce(
-    (acc, arg) => {
-      const pair = arg.split('=');
-      let flag = pair[0];
-      if (isNodeFlag(flag, false)) {
-        flag = flag.replace(/^--?/, '');
-        return arg.includes('=')
-          ? acc.concat([[flag, pair[1]]])
-          : acc.concat([[flag, true]]);
-      }
-      return acc;
-    },
-    []
-  );
+  const allArgs = Array.isArray(args) ? args : args.split(' ');
+  const nodeArgs = allArgs.reduce((acc, arg, index, allArgs) => {
+    const maybeFlag = allArgs[index - 1];
+
+    if (isNumeric(arg) && (!maybeFlag || !isMochaFlag(maybeFlag))) {
+      throw createUnsupportedError(
+        `Option ${arg} is unsupported by the mocha cli`
+      );
+    }
+    if (
+      isNumeric(arg) &&
+      isMochaFlag(maybeFlag) &&
+      expectedTypeForFlag(maybeFlag) !== 'number'
+    ) {
+      throw createInvalidArgumentTypeError(
+        `Mocha flag '--${maybeFlag}' given invalid option: '${arg}'`,
+        Number(arg),
+        expectedTypeForFlag(maybeFlag)
+      );
+    }
+
+    const pair = arg.split('=');
+    let flag = pair[0];
+    if (isNodeFlag(flag, false)) {
+      flag = flag.replace(/^--?/, '');
+      return arg.includes('=')
+        ? acc.concat([[flag, pair[1]]])
+        : acc.concat([[flag, true]]);
+    }
+    return acc;
+  }, []);
 
   const result = yargsParser.detailed(args, {
     configuration,

lib/cli/run-option-metadata.js

@@ -50,17 +50,8 @@ const TYPES = (exports.types = {
     'sort',
     'watch'
   ],
-  number: ['retries', 'jobs'],
-  string: [
-    'config',
-    'fgrep',
-    'grep',
-    'package',
-    'reporter',
-    'ui',
-    'slow',
-    'timeout'
-  ]
+  number: ['retries', 'jobs', 'slow', 'timeout'],
+  string: ['config', 'fgrep', 'grep', 'package', 'reporter', 'ui']
 });
 
 /**
@@ -114,3 +105,23 @@ const ALL_MOCHA_FLAGS = Object.keys(TYPES).reduce((acc, key) => {
 exports.isMochaFlag = flag => {
   return ALL_MOCHA_FLAGS.has(flag.replace(/^--?/, ''));
 };
+
+/**
+ * Returns expected yarg option type for a given mocha flag.
+ * @param {string} flag - Flag to check (can be with out without leading "--"")
+ * @returns {string | undefined} - If flag is a valid mocha flag, the expected type of argument for this flag is returned, otherwise undefined is returned.
+ */
+exports.expectedTypeForFlag = flag => {
+  const normalizedName = flag?.replace(/^--?/, '');
+
+  // If flag is an alias, get it's full name.
+  const aliases = exports.aliases;
+  const fullFlagName =
+    Object.keys(aliases).find(flagName =>
+      aliases[flagName].includes(normalizedName)
+    ) || normalizedName;
+
+  return Object.keys(TYPES).find(flagType =>
+    TYPES[flagType].includes(fullFlagName)
+  );
+};

lib/utils.js

@@ -689,3 +689,10 @@ exports.breakCircularDeps = inputObj => {
 
   return _breakCircularDeps(inputObj);
 };
+
+/**
+ * Checks if provided input can be parsed as a JavaScript Number.
+ */
+exports.isNumeric = input => {
+  return !isNaN(parseFloat(input));
+};

test/node-unit/cli/mocha-flags.spec.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const {
+  types,
+  expectedTypeForFlag
+} = require('../../../lib/cli/run-option-metadata');
+
+describe('mocha-flags', function () {
+  describe('expectedTypeForFlag()', function () {
+    it('returns expected type for all mocha flags', function () {
+      Object.entries(types).forEach(([dataType, flags]) => {
+        flags.forEach(flag => {
+          expect(expectedTypeForFlag(flag), 'to equal', dataType);
+        });
+      });
+    });
+
+    it('returns undefined for node flags', function () {
+      expect(expectedTypeForFlag('--throw-deprecation'), 'to equal', undefined);
+      expect(expectedTypeForFlag('throw-deprecation'), 'to equal', undefined);
+    });
+
+    it('returns undefined for unsupported flags', function () {
+      expect(expectedTypeForFlag('--foo'), 'to equal', undefined);
+    });
+  });
+});

test/node-unit/cli/options.spec.js

@@ -3,6 +3,7 @@
 const sinon = require('sinon');
 const rewiremock = require('rewiremock/node');
 const {ONE_AND_DONE_ARGS} = require('../../../lib/cli/one-and-dones');
+const {constants} = require('../../../lib/errors');
 
 const modulePath = require.resolve('../../../lib/cli/options');
 const mocharcPath = require.resolve('../../../lib/mocharc.json');
@@ -294,7 +295,6 @@ describe('options', function () {
 
             result = loadOptions('--no-diff --no-config');
           });
-
           it('should return parsed args, default config and package.json', function () {
             expect(
               result,
@@ -526,7 +526,7 @@ describe('options', function () {
           loadOptions('--timeout 500'),
           'to have property',
           'timeout',
-          '500'
+          500
         );
       });
 
@@ -676,5 +676,100 @@ describe('options', function () {
         ]);
       });
     });
+
+    describe('"numeric arguments"', function () {
+      const numericArg = 123;
+
+      const unsupportedError = arg => {
+        return {
+          message: `Option ${arg} is unsupported by the mocha cli`,
+          code: constants.UNSUPPORTED
+        };
+      };
+
+      const invalidArgError = (flag, arg, expectedType = 'string') => {
+        return {
+          message: `Mocha flag '--${flag}' given invalid option: '${arg}'`,
+          code: constants.INVALID_ARG_TYPE,
+          argument: arg,
+          actual: 'number',
+          expected: expectedType
+        };
+      };
+
+      beforeEach(function () {
+        readFileSync = sinon.stub();
+        findConfig = sinon.stub();
+        loadConfig = sinon.stub();
+        findupSync = sinon.stub();
+        loadOptions = proxyLoadOptions({
+          readFileSync,
+          findConfig,
+          loadConfig,
+          findupSync
+        });
+      });
+
+      it('throws UNSUPPORTED error when numeric option is passed to cli', function () {
+        expect(
+          () => loadOptions(`${numericArg}`),
+          'to throw',
+          unsupportedError(numericArg)
+        );
+      });
+
+      it('throws INVALID_ARG_TYPE error when numeric argument is passed to mocha flag that does not accept numeric value', function () {
+        const flag = '--delay';
+        expect(
+          () => loadOptions(`${flag} ${numericArg}`),
+          'to throw',
+          invalidArgError(flag, numericArg, 'boolean')
+        );
+      });
+
+      it('throws INVALID_ARG_TYPE error when incompatible flag does not have preceding "--"', function () {
+        const flag = 'delay';
+        expect(
+          () => loadOptions(`${flag} ${numericArg}`),
+          'to throw',
+          invalidArgError(flag, numericArg, 'boolean')
+        );
+      });
+
+      it('shows correct flag in error when multiple mocha flags have numeric values', function () {
+        const flag = '--delay';
+        expect(
+          () =>
+            loadOptions(
+              `--timeout ${numericArg} ${flag} ${numericArg} --retries ${numericArg}`
+            ),
+          'to throw',
+          invalidArgError(flag, numericArg, 'boolean')
+        );
+      });
+
+      it('throws UNSUPPORTED error when numeric arg is passed to unsupported flag', function () {
+        const invalidFlag = 'foo';
+        expect(
+          () => loadOptions(`${invalidFlag} ${numericArg}`),
+          'to throw',
+          unsupportedError(numericArg)
+        );
+      });
+
+      it('does not throw error if numeric value is passed to a compatible mocha flag', function () {
+        expect(() => loadOptions(`--retries ${numericArg}`), 'not to throw');
+      });
+
+      it('does not throw error if numeric value is passed to a node options', function () {
+        expect(
+          () =>
+            loadOptions(
+              `--secure-heap-min=${numericArg} --conditions=${numericArg}`
+            ),
+          'not to throw'
+        );
+      });
+    });
   });
 });

test/node-unit/utils.spec.js

@@ -45,5 +45,16 @@ describe('utils', function () {
         );
       });
     });
+    describe('isNumeric()', function () {
+      it('returns true for a number type', function () {
+        expect(utils.isNumeric(42), 'to equal', true);
+      });
+      it('returns true for a string that can be parsed as a number', function () {
+        expect(utils.isNumeric('42'), 'to equal', true);
+      });
+      it('returns false for a string that cannot be parsed as a number', function () {
+        expect(utils.isNumeric('foo'), 'to equal', false);
+      });
+    });
   });
 });