fix timeout/slow string values and duplicate arguments

lib/cli/run-option-metadata.js

@@ -44,8 +44,8 @@ exports.types = {
     'sort',
     'watch'
   ],
-  number: ['retries', 'slow', 'timeout'],
-  string: ['fgrep', 'grep', 'package', 'reporter', 'ui']
+  number: ['retries'],
+  string: ['fgrep', 'grep', 'package', 'reporter', 'ui', 'slow', 'timeout']
 };
 
 /**

lib/cli/run.js

@@ -258,6 +258,13 @@ exports.builder = yargs =>
         }
       });
 
+      types.boolean
+        .concat(types.string, types.number)
+        .filter(opt => Array.isArray(argv[opt]))
+        .forEach(opt => {
+          argv[opt] = argv[opt].pop();
+        });
+
       // yargs.implies() isn't flexible enough to handle this
       if (argv.invert && !('fgrep' in argv || 'grep' in argv)) {
         throw createMissingArgumentError(

test/integration/duplicate-arguments.spec.js

@@ -0,0 +1,36 @@
+'use strict';
+
+var runMocha = require('./helpers').runMocha;
+
+describe('when non-array argument is provided multiple times', function() {
+  describe('when the same argument name is used', function() {
+    it('should prefer the last value', function(done) {
+      runMocha(
+        'passing-sync',
+        ['--no-async-only', '--async-only', '--no-async-only'],
+        function(err, result) {
+          if (err) {
+            return done(err);
+          }
+          expect(result, 'to have passed');
+          done();
+        }
+      );
+    });
+  });
+
+  describe('when a different argument name is used', function() {
+    it('should prefer the last value', function(done) {
+      runMocha('passing-async', ['--timeout', '100', '-t', '10'], function(
+        err,
+        result
+      ) {
+        if (err) {
+          return done(err);
+        }
+        expect(result, 'to have failed');
+        done();
+      });
+    });
+  });
+});

test/integration/fixtures/options/slow-test.fixture.js

@@ -0,0 +1,11 @@
+'use strict';
+
+describe('a suite', function() {
+  it('should succeed in 500ms', function(done) {
+    setTimeout(done, 500);
+  });
+
+  it('should succeed in 1.5s', function(done) {
+    setTimeout(done, 1500);
+  });
+});

test/integration/fixtures/passing-async.fixture.js

@@ -0,0 +1,7 @@
+'use strict';
+
+describe('a suite', function() {
+  it('should succeed in 50ms', function(done) {
+    setTimeout(done, 50);
+  });
+});

test/integration/fixtures/passing-sync.fixture.js

@@ -0,0 +1,6 @@
+'use strict';
+
+describe('a suite', function() {
+  it('should succeed', function() {
+  });
+});

test/integration/invalid-arguments.spec.js

@@ -3,18 +3,20 @@
 var invokeMocha = require('./helpers').invokeMocha;
 
 describe('invalid arguments', function() {
-  it('should exit with failure if arguments are invalid', function(done) {
-    invokeMocha(
-      ['--ui'],
-      function(err, result) {
-        if (err) {
-          return done(err);
-        }
-        expect(result, 'to have failed');
-        expect(result.output, 'to match', /not enough arguments/i);
-        done();
-      },
-      {stdio: 'pipe'}
-    );
+  describe('when argument is missing required value', function() {
+    it('should exit with failure', function(done) {
+      invokeMocha(
+        ['--ui'],
+        function(err, result) {
+          if (err) {
+            return done(err);
+          }
+          expect(result, 'to have failed');
+          expect(result.output, 'to match', /not enough arguments/i);
+          done();
+        },
+        {stdio: 'pipe'}
+      );
+    });
   });
 });

test/integration/options/timeout.spec.js

@@ -0,0 +1,52 @@
+'use strict';
+
+var helpers = require('../helpers');
+var runMochaJSON = helpers.runMochaJSON;
+
+describe('--timeout', function() {
+  it('should allow human-readable string value', function(done) {
+    runMochaJSON('options/slow-test', ['--timeout', '1s'], function(err, res) {
+      if (err) {
+        done(err);
+        return;
+      }
+      expect(res, 'to have failed')
+        .and('to have passed test count', 1)
+        .and('to have failed test count', 1);
+      done();
+    });
+  });
+
+  it('should allow numeric value', function(done) {
+    runMochaJSON('options/slow-test', ['--timeout', '1000'], function(
+      err,
+      res
+    ) {
+      if (err) {
+        done(err);
+        return;
+      }
+      expect(res, 'to have failed')
+        .and('to have passed test count', 1)
+        .and('to have failed test count', 1);
+      done();
+    });
+  });
+
+  it('should allow multiple values', function(done) {
+    var fixture = 'options/slow-test';
+    runMochaJSON(fixture, ['--timeout', '2s', '--timeout', '1000'], function(
+      err,
+      res
+    ) {
+      if (err) {
+        done(err);
+        return;
+      }
+      expect(res, 'to have failed')
+        .and('to have passed test count', 1)
+        .and('to have failed test count', 1);
+      done();
+    });
+  });
+});

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

@@ -629,7 +629,7 @@ describe('options', function() {
           findupSync
         });
 
-        expect(loadOptions(), 'to satisfy', {timeout: 800, require: ['foo']});
+        expect(loadOptions(), 'to satisfy', {timeout: '800', require: ['foo']});
       });
 
       it('should prioritize package.json over mocha.opts', function() {
@@ -692,7 +692,7 @@ describe('options', function() {
           loadOptions('--timeout 500'),
           'to have property',
           'timeout',
-          500
+          '500'
         );
       });
     });