child_process: use internal/errors

lib/internal/child_process.js

@@ -256,8 +256,10 @@ ChildProcess.prototype.spawn = function(options) {
   var ipcFd;
   var i;
 
-  if (options === null || typeof options !== 'object')
-    throw new TypeError('"options" must be an object');
+  if (options === null || typeof options !== 'object') {
+    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'object',
+                               options);
+  }
 
   // If no `stdio` option was given - use default
   var stdio = options.stdio || 'pipe';
@@ -272,23 +274,27 @@ ChildProcess.prototype.spawn = function(options) {
     // Let child process know about opened IPC channel
     if (options.envPairs === undefined)
       options.envPairs = [];
-    else if (!Array.isArray(options.envPairs))
-      throw new TypeError('"envPairs" must be an array');
+    else if (!Array.isArray(options.envPairs)) {
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.envPairs',
+                                 'array', options.envPairs);
+    }
 
     options.envPairs.push('NODE_CHANNEL_FD=' + ipcFd);
   }
 
-  if (typeof options.file === 'string')
-    this.spawnfile = options.file;
-  else
-    throw new TypeError('"file" must be a string');
+  if (typeof options.file !== 'string') {
+    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.file', 'string',
+                               options.file);
+  }
+  this.spawnfile = options.file;
 
   if (Array.isArray(options.args))
     this.spawnargs = options.args;
   else if (options.args === undefined)
     this.spawnargs = [];
   else
-    throw new TypeError('"args" must be an array');
+    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.args', 'array',
+                               options.args);
 
   var err = this._handle.spawn(options);
 
@@ -545,7 +551,8 @@ function setupChannel(target, channel) {
       options = undefined;
     } else if (options !== undefined &&
                (options === null || typeof options !== 'object')) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'Object');
+      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'object',
+                                 options);
     }
 
     options = Object.assign({swallowErrors: false}, options);

test/parallel/test-child-process-constructor.js

@@ -5,51 +5,71 @@ const assert = require('assert');
 const { ChildProcess } = require('child_process');
 assert.strictEqual(typeof ChildProcess, 'function');
 
+function typeName(value) {
+  return value === null ? 'null' : typeof value;
+}
+
 {
   // Verify that invalid options to spawn() throw.
   const child = new ChildProcess();
-  const re = /^TypeError: "options" must be an object$/;
 
   [undefined, null, 'foo', 0, 1, NaN, true, false].forEach((options) => {
     assert.throws(() => {
       child.spawn(options);
-    }, re);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "options" argument must be of type object. Received type ' +
+               typeName(options)
+    }));
   });
 }
 
 {
   // Verify that spawn throws if file is not a string.
   const child = new ChildProcess();
-  const re = /^TypeError: "file" must be a string$/;
 
   [undefined, null, 0, 1, NaN, true, false, {}].forEach((file) => {
     assert.throws(() => {
       child.spawn({ file });
-    }, re);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "options.file" property must be of type string. Received ' +
+               'type ' + typeName(file)
+    }));
   });
 }
 
 {
   // Verify that spawn throws if envPairs is not an array or undefined.
   const child = new ChildProcess();
-  const re = /^TypeError: "envPairs" must be an array$/;
 
   [null, 0, 1, NaN, true, false, {}, 'foo'].forEach((envPairs) => {
     assert.throws(() => {
       child.spawn({ envPairs, stdio: ['ignore', 'ignore', 'ignore', 'ipc'] });
-    }, re);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "options.envPairs" property must be of type array. ' +
+               'Received type ' + typeName(envPairs)
+    }));
   });
 }
 
 {
   // Verify that spawn throws if args is not an array or undefined.
   const child = new ChildProcess();
-  const re = /^TypeError: "args" must be an array$/;
 
   [null, 0, 1, NaN, true, false, {}, 'foo'].forEach((args) => {
     assert.throws(() => {
       child.spawn({ file: 'foo', args });
-    }, re);
+    }, common.expectsError({
+      code: 'ERR_INVALID_ARG_TYPE',
+      type: TypeError,
+      message: 'The "options.args" property must be of type array. Received ' +
+               'type ' + typeName(args)
+    }));
   });
 }