Move to Jest as testing framework

.eslintrc.json

@@ -1,5 +1,6 @@
 {
-  "extends": "standard",
+  "extends": ["standard", "plugin:jest/recommended"],
+  "plugins": ["jest"],
   "rules": {
     "one-var": "off",
     "semi": ["error", "always"],

index.js

@@ -87,6 +87,30 @@ Option.prototype.is = function(arg) {
   return this.short === arg || this.long === arg;
 };
 
+/**
+ * CommanderError class
+ * @class
+ */
+class CommanderError extends Error {
+  /**
+   * Constructs the CommanderError class
+   * @param {Number} exitCode suggested exit code which could be used with process.exit
+   * @param {String} code an id string representing the error
+   * @param {String} message human-readable description of the error
+   * @constructor
+   */
+  constructor(exitCode, code, message) {
+    super(message);
+    // properly capture stack trace in Node.js
+    Error.captureStackTrace(this, this.constructor);
+    this.name = this.constructor.name;
+    this.code = code;
+    this.exitCode = exitCode;
+  }
+}
+
+exports.CommanderError = CommanderError;
+
 /**
  * Initialize a new `Command`.
  *
@@ -157,6 +181,8 @@ Command.prototype.command = function(nameAndArgs, actionOptsOrExecDesc, execOpts
   cmd._helpDescription = this._helpDescription;
   cmd._helpShortFlag = this._helpShortFlag;
   cmd._helpLongFlag = this._helpLongFlag;
+  cmd._exitCallback = this._exitCallback;
+
   cmd._executableFile = opts.executableFile; // Custom name for executable file
   this.commands.push(cmd);
   cmd.parseExpectedArgs(args);
@@ -228,6 +254,47 @@ Command.prototype.parseExpectedArgs = function(args) {
   return this;
 };
 
+/**
+ * Register callback `fn` to use as replacement for calling process.exit.
+ *
+ * @param {Function} fn callback which will be passed a CommanderError
+ * @return {Command} for chaining
+ * @api public
+ */
+
+Command.prototype._exitOverride = function(fn) {
+  if (fn) {
+    this._exitCallback = fn;
+  } else {
+    this._exitCallback = function(err) {
+      if (err.code !== 'commander.executeSubCommandAsync') {
+        throw err;
+      } else {
+        // Async callback from spawn events, not useful to throw.
+      }
+    };
+  }
+  return this;
+};
+
+/**
+ * Call process.exit, and _exitCallback if defined.
+ *
+ * @param {Number} exitCode exit code for using with process.exit
+ * @param {String} code an id string representing the error
+ * @param {String} message human-readable description of the error
+ * @return never
+ * @api private
+ */
+
+Command.prototype._exit = function(exitCode, code, message) {
+  if (this._exitCallback) {
+    this._exitCallback(new CommanderError(exitCode, code, message));
+    // Expecting this line is not reached.
+  }
+  process.exit(exitCode);
+};
+
 /**
  * Register callback `fn` for the command.
  *
@@ -586,14 +653,30 @@ Command.prototype.executeSubCommand = function(argv, args, unknown, executableFi
       }
     });
   });
-  proc.on('close', process.exit.bind(process));
+
+  // By default terminate process when spawned process terminates.
+  // Suppressing the exit if exitCallback defined is a bit messy and of limited use, but does allow process to stay running!
+  const exitCallback = this._exitCallback;
+  if (!exitCallback) {
+    proc.on('close', process.exit.bind(process));
+  } else {
+    proc.on('close', () => {
+      exitCallback(new CommanderError(process.exitCode || 0, 'commander.executeSubCommandAsync', '(close)'));
+    });
+  }
   proc.on('error', function(err) {
     if (err.code === 'ENOENT') {
       console.error('error: %s(1) does not exist, try --help', bin);
     } else if (err.code === 'EACCES') {
       console.error('error: %s(1) not executable. try chmod or run with root', bin);
     }
-    process.exit(1);
+    if (!exitCallback) {
+      process.exit(1);
+    } else {
+      const wrappedError = new CommanderError(1, 'commander.executeSubCommandAsync', '(error)');
+      wrappedError.nestedError = err;
+      exitCallback(wrappedError);
+    }
   });
 
   // Store the reference to the child process
@@ -810,8 +893,9 @@ Command.prototype.opts = function() {
  */
 
 Command.prototype.missingArgument = function(name) {
-  console.error("error: missing required argument '%s'", name);
-  process.exit(1);
+  const message = `error: missing required argument '${name}'`;
+  console.error(message);
+  this._exit(1, 'commander.missingArgument', message);
 };
 
 /**
@@ -823,12 +907,14 @@ Command.prototype.missingArgument = function(name) {
  */
 
 Command.prototype.optionMissingArgument = function(option, flag) {
+  let message;
   if (flag) {
-    console.error("error: option '%s' argument missing, got '%s'", option.flags, flag);
+    message = `error: option '${option.flags}' argument missing, got '${flag}'`;
   } else {
-    console.error("error: option '%s' argument missing", option.flags);
+    message = `error: option '${option.flags}' argument missing`;
   }
-  process.exit(1);
+  console.error(message);
+  this._exit(1, 'commander.optionMissingArgument', message);
 };
 
 /**
@@ -840,8 +926,9 @@ Command.prototype.optionMissingArgument = function(option, flag) {
 
 Command.prototype.unknownOption = function(flag) {
   if (this._allowUnknownOption) return;
-  console.error("error: unknown option '%s'", flag);
-  process.exit(1);
+  const message = `error: unknown option '${flag}'`;
+  console.error(message);
+  this._exit(1, 'commander.unknownOption', message);
 };
 
 /**
@@ -852,8 +939,9 @@ Command.prototype.unknownOption = function(flag) {
  */
 
 Command.prototype.variadicArgNotLast = function(name) {
-  console.error("error: variadic arguments must be last '%s'", name);
-  process.exit(1);
+  const message = `error: variadic arguments must be last '${name}'`;
+  console.error(message);
+  this._exit(1, 'commander.variadicArgNotLast', message);
 };
 
 /**
@@ -881,7 +969,7 @@ Command.prototype.version = function(str, flags, description) {
   this.options.push(versionOption);
   this.on('option:' + this._versionOptionName, function() {
     process.stdout.write(str + '\n');
-    process.exit(0);
+    this._exit(0, 'commander.version', str);
   });
   return this;
 };
@@ -1208,7 +1296,9 @@ Command.prototype.helpOption = function(flags, description) {
 
 Command.prototype.help = function(cb) {
   this.outputHelp(cb);
-  process.exit();
+  // exitCode: preserving original behaviour which was calling process.exit()
+  // message: do not have all displayed text available so only passing placeholder.
+  this._exit(process.exitCode || 0, 'commander.help', '(outputHelp)');
 };
 
 /**
@@ -1253,7 +1343,8 @@ function outputHelpIfNecessary(cmd, options) {
   for (var i = 0; i < options.length; i++) {
     if (options[i] === cmd._helpLongFlag || options[i] === cmd._helpShortFlag) {
       cmd.outputHelp();
-      process.exit(0);
+      // (Do not have all displayed text available so only passing placeholder.)
+      cmd._exit(0, 'commander.helpDisplayed', '(outputHelp)');
     }
   }
 }