net: convert to using internal/errors

Covert lib/net.js over to using lib/internal/errors.js

- Replace thrown errors in lib/net.js
  with errors from lib/internal/errors.
  The ERR_INVALID_OPT_VALUE error have been used
  in the Server.prototype.listen() method
- Update tests according to the above modifications

PR-URL: https://github.com/nodejs/node/pull/14782
Refs: https://github.com/nodejs/node/issues/11273
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

10 files changed, 131 insertions, 108 deletions

diff --git a/test/parallel/test-dns.js b/test/parallel/test-dns.js
index ba905d7490..02bb5f7176 100644
--- a/test/parallel/test-dns.js
+++ b/test/parallel/test-dns.js
@@ -220,24 +220,23 @@ assert.throws(() => {
   message: `The value "${invalidHost}" is invalid for option "host"`
 }));
 
-const badPortMsg = common.expectsError({
-  code: 'ERR_SOCKET_BAD_PORT',
-  type: RangeError,
-  message: 'Port should be > 0 and < 65536'
-}, 4);
-assert.throws(() => dns.lookupService('0.0.0.0', null, common.mustNotCall()),
-              badPortMsg);
-
-assert.throws(
-  () => dns.lookupService('0.0.0.0', undefined, common.mustNotCall()),
-  badPortMsg
-);
-
-assert.throws(() => dns.lookupService('0.0.0.0', 65538, common.mustNotCall()),
-              badPortMsg);
-
-assert.throws(() => dns.lookupService('0.0.0.0', 'test', common.mustNotCall()),
-              badPortMsg);
+const portErr = (port) => {
+  common.expectsError(
+    () => {
+      dns.lookupService('0.0.0.0', port, common.mustNotCall());
+    },
+    {
+      code: 'ERR_SOCKET_BAD_PORT',
+      message:
+        `Port should be > 0 and < 65536. Received ${port}.`,
+      type: RangeError
+    }
+  );
+};
+portErr(null);
+portErr(undefined);
+portErr(65538);
+portErr('test');
 
 assert.throws(() => {
   dns.lookupService('0.0.0.0', 80, null);
diff --git a/test/parallel/test-internal-errors.js b/test/parallel/test-internal-errors.js
index 93757ae66c..80edc25df1 100644
--- a/test/parallel/test-internal-errors.js
+++ b/test/parallel/test-internal-errors.js
@@ -216,6 +216,10 @@ assert.strictEqual(
   errors.message('ERR_INVALID_ARG_TYPE', [['a', 'b', 'c'], 'not d']),
   'The "a", "b", "c" arguments must not be of type d');
 
+// Test ERR_INVALID_FD_TYPE
+assert.strictEqual(errors.message('ERR_INVALID_FD_TYPE', ['a']),
+                   'Unsupported fd type: a');
+
 // Test ERR_INVALID_URL_SCHEME
 assert.strictEqual(errors.message('ERR_INVALID_URL_SCHEME', ['file']),
                    'The URL must be of scheme file');
@@ -246,6 +250,10 @@ assert.throws(
     message: /^At least one arg needs to be specified$/
   }));
 
+// Test ERR_SOCKET_BAD_PORT
+assert.strictEqual(
+  errors.message('ERR_SOCKET_BAD_PORT', [0]),
+  'Port should be > 0 and < 65536. Received 0.');
 
 // Test ERR_TLS_CERT_ALTNAME_INVALID
 assert.strictEqual(
diff --git a/test/parallel/test-net-connect-options-port.js b/test/parallel/test-net-connect-options-port.js
index 9e4d5991fd..975022be8a 100644
--- a/test/parallel/test-net-connect-options-port.js
+++ b/test/parallel/test-net-connect-options-port.js
@@ -27,35 +27,33 @@ const net = require('net');
 
 // Test wrong type of ports
 {
-  function portTypeError(opt) {
-    const prefix = '"port" option should be a number or string: ';
-    const cleaned = opt.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
-    return new RegExp(`^TypeError: ${prefix}${cleaned}$`);
-  }
-
-  syncFailToConnect(true, portTypeError('true'));
-  syncFailToConnect(false, portTypeError('false'));
-  syncFailToConnect([], portTypeError(''), true);
-  syncFailToConnect({}, portTypeError('[object Object]'), true);
-  syncFailToConnect(null, portTypeError('null'));
+  const portTypeError = common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }, 96);
+
+  syncFailToConnect(true, portTypeError);
+  syncFailToConnect(false, portTypeError);
+  syncFailToConnect([], portTypeError, true);
+  syncFailToConnect({}, portTypeError, true);
+  syncFailToConnect(null, portTypeError);
 }
 
 // Test out of range ports
 {
-  function portRangeError(opt) {
-    const prefix = '"port" option should be >= 0 and < 65536: ';
-    const cleaned = opt.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
-    return new RegExp(`^RangeError: ${prefix}${cleaned}$`);
-  }
-
-  syncFailToConnect('', portRangeError(''));
-  syncFailToConnect(' ', portRangeError(' '));
-  syncFailToConnect('0x', portRangeError('0x'), true);
-  syncFailToConnect('-0x1', portRangeError('-0x1'), true);
-  syncFailToConnect(NaN, portRangeError('NaN'));
-  syncFailToConnect(Infinity, portRangeError('Infinity'));
-  syncFailToConnect(-1, portRangeError('-1'));
-  syncFailToConnect(65536, portRangeError('65536'));
+  const portRangeError = common.expectsError({
+    code: 'ERR_SOCKET_BAD_PORT',
+    type: RangeError
+  }, 168);
+
+  syncFailToConnect('', portRangeError);
+  syncFailToConnect(' ', portRangeError);
+  syncFailToConnect('0x', portRangeError, true);
+  syncFailToConnect('-0x1', portRangeError, true);
+  syncFailToConnect(NaN, portRangeError);
+  syncFailToConnect(Infinity, portRangeError);
+  syncFailToConnect(-1, portRangeError);
+  syncFailToConnect(65536, portRangeError);
 }
 
 // Test invalid hints
@@ -129,33 +127,40 @@ function doConnect(args, getCb) {
   ];
 }
 
-function syncFailToConnect(port, regexp, optOnly) {
+function syncFailToConnect(port, assertErr, optOnly) {
   if (!optOnly) {
     // connect(port, cb) and connect(port)
     const portArgBlocks = doConnect([port], () => common.mustNotCall());
     for (const block of portArgBlocks) {
-      assert.throws(block, regexp, `${block.name}(${port})`);
+      assert.throws(block,
+                    assertErr,
+                    `${block.name}(${port})`);
     }
 
     // connect(port, host, cb) and connect(port, host)
     const portHostArgBlocks = doConnect([port, 'localhost'],
                                         () => common.mustNotCall());
     for (const block of portHostArgBlocks) {
-      assert.throws(block, regexp, `${block.name}(${port}, 'localhost')`);
+      assert.throws(block,
+                    assertErr,
+                    `${block.name}(${port}, 'localhost')`);
     }
   }
   // connect({port}, cb) and connect({port})
   const portOptBlocks = doConnect([{ port }],
                                   () => common.mustNotCall());
   for (const block of portOptBlocks) {
-    assert.throws(block, regexp, `${block.name}({port: ${port}})`);
+    assert.throws(block,
+                  assertErr,
+                  `${block.name}({port: ${port}})`);
   }
 
   // connect({port, host}, cb) and connect({port, host})
   const portHostOptBlocks = doConnect([{ port: port, host: 'localhost' }],
                                       () => common.mustNotCall());
   for (const block of portHostOptBlocks) {
-    assert.throws(block, regexp,
+    assert.throws(block,
+                  assertErr,
                   `${block.name}({port: ${port}, host: 'localhost'})`);
   }
 }
diff --git a/test/parallel/test-net-localerror.js b/test/parallel/test-net-localerror.js
index 845983843d..91a7b38c3e 100644
--- a/test/parallel/test-net-localerror.js
+++ b/test/parallel/test-net-localerror.js
@@ -20,25 +20,24 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
-const assert = require('assert');
+const common = require('../common');
 const net = require('net');
 
-// Using port 0 as localPort / localAddress is already invalid.
+const connect = (opts, code, type) => {
+  common.expectsError(
+    () => net.connect(opts),
+    { code, type }
+  );
+};
+
 connect({
   host: 'localhost',
   port: 0,
-  localPort: 'foobar',
-}, /^TypeError: "localPort" option should be a number: foobar$/);
+  localAddress: 'foobar',
+}, 'ERR_INVALID_IP_ADDRESS', TypeError);
 
 connect({
   host: 'localhost',
   port: 0,
-  localAddress: 'foobar',
-}, /^TypeError: "localAddress" option must be a valid IP: foobar$/);
-
-function connect(opts, msg) {
-  assert.throws(() => {
-    net.connect(opts);
-  }, msg);
-}
+  localPort: 'foobar',
+}, 'ERR_INVALID_ARG_TYPE', TypeError);
diff --git a/test/parallel/test-net-options-lookup.js b/test/parallel/test-net-options-lookup.js
index f0e8b34c80..337a071a19 100644
--- a/test/parallel/test-net-options-lookup.js
+++ b/test/parallel/test-net-options-lookup.js
@@ -1,10 +1,8 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
-const expectedError = /^TypeError: "lookup" option should be a function$/;
-
 ['foobar', 1, {}, []].forEach((input) => connectThrows(input));
 
 // Using port 0 as lookup is emitted before connecting.
@@ -17,7 +15,10 @@ function connectThrows(input) {
 
   assert.throws(() => {
     net.connect(opts);
-  }, expectedError);
+  }, common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }));
 }
 
 connectDoesNotThrow(() => {});
diff --git a/test/parallel/test-net-server-listen-options.js b/test/parallel/test-net-server-listen-options.js
index 9f44a5bd3b..bc28b57ac1 100644
--- a/test/parallel/test-net-server-listen-options.js
+++ b/test/parallel/test-net-server-listen-options.js
@@ -2,21 +2,9 @@
 const common = require('../common');
 const assert = require('assert');
 const net = require('net');
-const util = require('util');
 
 function close() { this.close(); }
 
-function listenError(literals, ...values) {
-  let result = literals[0];
-  for (const [i, value] of values.entries()) {
-    const str = util.inspect(value);
-    // Need to escape special characters.
-    result += str.replace(/[\\^$.*+?()[\]{}|=!<>:-]/g, '\\$&');
-    result += literals[i + 1];
-  }
-  return new RegExp(`Error: Invalid listen argument: ${result}`);
-}
-
 {
   // Test listen()
   net.createServer().listen().on('listening', common.mustCall(close));
@@ -36,7 +24,13 @@ const listenOnPort = [
 ];
 
 {
-  const portError = /^RangeError: "port" argument must be >= 0 and < 65536$/;
+  const assertPort = () => {
+    return common.expectsError({
+      code: 'ERR_SOCKET_BAD_PORT',
+      type: RangeError
+    });
+  };
+
   for (const listen of listenOnPort) {
     // Arbitrary unused ports
     listen('0', common.mustCall(close));
@@ -44,37 +38,36 @@ const listenOnPort = [
     listen(undefined, common.mustCall(close));
     listen(null, common.mustCall(close));
     // Test invalid ports
-    assert.throws(() => listen(-1, common.mustNotCall()), portError);
-    assert.throws(() => listen(NaN, common.mustNotCall()), portError);
-    assert.throws(() => listen(123.456, common.mustNotCall()), portError);
-    assert.throws(() => listen(65536, common.mustNotCall()), portError);
-    assert.throws(() => listen(1 / 0, common.mustNotCall()), portError);
-    assert.throws(() => listen(-1 / 0, common.mustNotCall()), portError);
+    assert.throws(() => listen(-1, common.mustNotCall()), assertPort());
+    assert.throws(() => listen(NaN, common.mustNotCall()), assertPort());
+    assert.throws(() => listen(123.456, common.mustNotCall()), assertPort());
+    assert.throws(() => listen(65536, common.mustNotCall()), assertPort());
+    assert.throws(() => listen(1 / 0, common.mustNotCall()), assertPort());
+    assert.throws(() => listen(-1 / 0, common.mustNotCall()), assertPort());
   }
   // In listen(options, cb), port takes precedence over path
   assert.throws(() => {
     net.createServer().listen({ port: -1, path: common.PIPE },
                               common.mustNotCall());
-  }, portError);
+  }, assertPort());
 }
 
 {
-  function shouldFailToListen(options, optionsInMessage) {
-    // Plain arguments get normalized into an object before
-    // formatted in message, options objects don't.
-    if (arguments.length === 1) {
-      optionsInMessage = options;
-    }
+  function shouldFailToListen(options) {
     const block = () => {
       net.createServer().listen(options, common.mustNotCall());
     };
-    assert.throws(block, listenError`${optionsInMessage}`,
-                  `expect listen(${util.inspect(options)}) to throw`);
+    assert.throws(block,
+                  common.expectsError({
+                    code: 'ERR_INVALID_OPT_VALUE',
+                    type: Error,
+                    message: /^The value "{.*}" is invalid for option "options"$/
+                  }));
   }
 
   shouldFailToListen(false, { port: false });
   shouldFailToListen({ port: false });
-  shouldFailToListen(true, { port: true });
+  shouldFailToListen(true);
   shouldFailToListen({ port: true });
   // Invalid fd as listen(handle)
   shouldFailToListen({ fd: -1 });
diff --git a/test/parallel/test-net-server-options.js b/test/parallel/test-net-server-options.js
index be7e40e49b..6b120821b0 100644
--- a/test/parallel/test-net-server-options.js
+++ b/test/parallel/test-net-server-options.js
@@ -1,9 +1,16 @@
 'use strict';
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
 assert.throws(function() { net.createServer('path'); },
-              /^TypeError: options must be an object$/);
+              common.expectsError({
+                code: 'ERR_INVALID_ARG_TYPE',
+                type: TypeError
+              }));
+
 assert.throws(function() { net.createServer(0); },
-              /^TypeError: options must be an object$/);
+              common.expectsError({
+                code: 'ERR_INVALID_ARG_TYPE',
+                type: TypeError
+              }));
diff --git a/test/parallel/test-net-socket-write-error.js b/test/parallel/test-net-socket-write-error.js
index 2af04d3109..0a2dd967df 100644
--- a/test/parallel/test-net-socket-write-error.js
+++ b/test/parallel/test-net-socket-write-error.js
@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 const net = require('net');
 
@@ -8,9 +8,11 @@ const server = net.createServer().listen(0, connectToServer);
 
 function connectToServer() {
   const client = net.createConnection(this.address().port, () => {
-    assert.throws(() => {
-      client.write(1337);
-    }, /Invalid data, chunk must be a string or buffer, not number/);
+    assert.throws(() => client.write(1337),
+                  common.expectsError({
+                    code: 'ERR_INVALID_ARG_TYPE',
+                    type: TypeError
+                  }));
 
     client.end();
   })
diff --git a/test/parallel/test-regress-GH-5727.js b/test/parallel/test-regress-GH-5727.js
index 7cedd831b2..053719c6fa 100644
--- a/test/parallel/test-regress-GH-5727.js
+++ b/test/parallel/test-regress-GH-5727.js
@@ -4,7 +4,6 @@ const assert = require('assert');
 const net = require('net');
 
 const invalidPort = -1 >>> 0;
-const errorMessage = /"port" argument must be >= 0 and < 65536/;
 
 net.Server().listen(0, function() {
   const address = this.address();
@@ -17,14 +16,23 @@ net.Server().listen(0, function() {
 // The first argument is a configuration object
 assert.throws(() => {
   net.Server().listen({ port: invalidPort }, common.mustNotCall());
-}, errorMessage);
+}, common.expectsError({
+  code: 'ERR_SOCKET_BAD_PORT',
+  type: RangeError
+}));
 
 // The first argument is the port, no IP given.
 assert.throws(() => {
   net.Server().listen(invalidPort, common.mustNotCall());
-}, errorMessage);
+}, common.expectsError({
+  code: 'ERR_SOCKET_BAD_PORT',
+  type: RangeError
+}));
 
 // The first argument is the port, the second an IP.
 assert.throws(() => {
   net.Server().listen(invalidPort, '0.0.0.0', common.mustNotCall());
-}, errorMessage);
+}, common.expectsError({
+  code: 'ERR_SOCKET_BAD_PORT',
+  type: RangeError
+}));
diff --git a/test/parallel/test-tls-lookup.js b/test/parallel/test-tls-lookup.js
index 4656d3e5cc..fddbb20ee0 100644
--- a/test/parallel/test-tls-lookup.js
+++ b/test/parallel/test-tls-lookup.js
@@ -6,8 +6,6 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const tls = require('tls');
 
-const expectedError = /^TypeError: "lookup" option should be a function$/;
-
 ['foobar', 1, {}, []].forEach(function connectThrows(input) {
   const opts = {
     host: 'localhost',
@@ -17,7 +15,10 @@ const expectedError = /^TypeError: "lookup" option should be a function$/;
 
   assert.throws(function() {
     tls.connect(opts);
-  }, expectedError);
+  }, common.expectsError({
+    code: 'ERR_INVALID_ARG_TYPE',
+    type: TypeError
+  }));
 });
 
 connectDoesNotThrow(common.mustCall(() => {}));