tools: eslint rule for assert.throws -> common.expectsError

test/.eslintrc.yaml

@@ -10,6 +10,7 @@ rules:
  # Custom rules in tools/eslint-rules
  prefer-assert-iferror: error
  prefer-assert-methods: error
+ prefer-common-expectserror: error
  prefer-common-mustnotcall: error
  crypto-check: error
  inspector-check: error

test/async-hooks/test-embedder.api.async-resource.js

@@ -17,12 +17,12 @@ common.expectsError(
  code: 'ERR_INVALID_ARG_TYPE',
  type: TypeError,
  });
-assert.throws(() => {
+common.expectsError(() => {
  new AsyncResource('invalid_trigger_id', { triggerAsyncId: null });
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_ASYNC_ID',
  type: RangeError,
-}));
+});
 
 assert.strictEqual(
  new AsyncResource('default_trigger_id').triggerAsyncId(),

test/parallel/test-assert-fail.js

@@ -1,5 +1,7 @@
 'use strict';
 
+/* eslint-disable prefer-common-expectserror */
+
 const common = require('../common');
 const assert = require('assert');
 

test/parallel/test-assert.js

@@ -20,6 +20,9 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
+
+/* eslint-disable prefer-common-expectserror */
+
 const common = require('../common');
 const assert = require('assert');
 const a = assert;

test/parallel/test-buffer-alloc.js

@@ -974,12 +974,11 @@ assert.strictEqual(SlowBuffer.prototype.offset, undefined);
 }
 
 // ParseArrayIndex() should reject values that don't fit in a 32 bits size_t.
-assert.throws(() => {
+common.expectsError(() => {
  const a = Buffer.alloc(1);
  const b = Buffer.alloc(1);
  a.copy(b, 0, 0x100000000, 0x100000001);
-}, common.expectsError(
- { code: undefined, type: RangeError, message: 'Index out of range' }));
+}, { code: undefined, type: RangeError, message: 'Index out of range' });
 
 // Unpooled buffer (replaces SlowBuffer)
 {

test/parallel/test-buffer-fill.js

@@ -424,21 +424,19 @@ common.expectsError(() => {
 
 // Testing process.binding. Make sure "end" is properly checked for -1 wrap
 // around.
-assert.throws(() => {
+common.expectsError(() => {
  process.binding('buffer').fill(Buffer.alloc(1), 1, 1, -2, 1);
-}, common.expectsError(
- { code: undefined, type: RangeError, message: 'Index out of range' }));
+}, { code: undefined, type: RangeError, message: 'Index out of range' });
 
 // Test that bypassing 'length' won't cause an abort.
-assert.throws(() => {
+common.expectsError(() => {
  const buf = new Buffer('w00t');
  Object.defineProperty(buf, 'length', {
  value: 1337,
  enumerable: true
  });
  buf.fill('');
-}, common.expectsError(
- { code: undefined, type: RangeError, message: 'Index out of range' }));
+}, { code: undefined, type: RangeError, message: 'Index out of range' });
 
 assert.deepStrictEqual(
  Buffer.allocUnsafeSlow(16).fill('ab', 'utf16le'),

test/parallel/test-console-instance.js

@@ -47,17 +47,17 @@ common.expectsError(
 );
 
 // Console constructor should throw if stderr exists but is not writable
-assert.throws(
+common.expectsError(
  () => {
  out.write = () => {};
  err.write = undefined;
  new Console(out, err);
  },
- common.expectsError({
+ {
  code: 'ERR_CONSOLE_WRITABLE_STREAM',
  type: TypeError,
  message: /stderr/
- })
+ }
 );
 
 out.write = err.write = (d) => {};

test/parallel/test-dns.js

@@ -205,20 +205,20 @@ assert.doesNotThrow(() => {
  }, common.mustCall());
 });
 
-assert.throws(() => dns.lookupService('0.0.0.0'), common.expectsError({
+common.expectsError(() => dns.lookupService('0.0.0.0'), {
  code: 'ERR_MISSING_ARGS',
  type: TypeError,
  message: 'The "host", "port", and "callback" arguments must be specified'
-}));
+});
 
 const invalidHost = 'fasdfdsaf';
-assert.throws(() => {
+common.expectsError(() => {
  dns.lookupService(invalidHost, 0, common.mustNotCall());
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_OPT_VALUE',
  type: TypeError,
  message: `The value "${invalidHost}" is invalid for option "host"`
-}));
+});
 
 const portErr = (port) => {
  common.expectsError(
@@ -238,9 +238,9 @@ portErr(undefined);
 portErr(65538);
 portErr('test');
 
-assert.throws(() => {
+common.expectsError(() => {
  dns.lookupService('0.0.0.0', 80, null);
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_CALLBACK',
  type: TypeError
-}));
+});

test/parallel/test-eslint-prefer-common-expectserror.js

@@ -0,0 +1,27 @@
+'use strict';
+
+require('../common');
+
+const RuleTester = require('../../tools/eslint').RuleTester;
+const rule = require('../../tools/eslint-rules/prefer-common-expectserror');
+
+const message = 'Please use common.expectsError(fn, err) instead of ' +
+ 'assert.throws(fn, common.expectsError(err)).';
+
+new RuleTester().run('prefer-common-expectserror', rule, {
+ valid: [
+ 'assert.throws(fn, /[a-z]/)',
+ 'assert.throws(function () {}, function() {})',
+ 'common.expectsError(function() {}, err)'
+ ],
+ invalid: [
+ {
+ code: 'assert.throws(function() {}, common.expectsError(err))',
+ errors: [{ message }]
+ },
+ {
+ code: 'assert.throws(fn, common.expectsError(err))',
+ errors: [{ message }]
+ }
+ ]
+});

test/parallel/test-http-outgoing-proto.js

@@ -21,80 +21,80 @@ assert.strictEqual(
  typeof ServerResponse.prototype._implicitHeader, 'function');
 
 // validateHeader
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.setHeader();
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_HTTP_TOKEN',
  type: TypeError,
  message: 'Header name must be a valid HTTP token ["undefined"]'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.setHeader('test');
-}, common.expectsError({
+}, {
  code: 'ERR_HTTP_INVALID_HEADER_VALUE',
  type: TypeError,
  message: 'Invalid value "undefined" for header "test"'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.setHeader(404);
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_HTTP_TOKEN',
  type: TypeError,
  message: 'Header name must be a valid HTTP token ["404"]'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.setHeader.call({ _header: 'test' }, 'test', 'value');
-}, common.expectsError({
+}, {
  code: 'ERR_HTTP_HEADERS_SENT',
  type: Error,
  message: 'Cannot set headers after they are sent to the client'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.setHeader('200', 'あ');
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_CHAR',
  type: TypeError,
  message: 'Invalid character in header content ["200"]'
-}));
+});
 
 // write
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.write();
-}, common.expectsError({
+}, {
  code: 'ERR_METHOD_NOT_IMPLEMENTED',
  type: Error,
  message: 'The _implicitHeader() method is not implemented'
-}));
+});
 
 assert(OutgoingMessage.prototype.write.call({ _header: 'test' }));
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' });
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_ARG_TYPE',
  type: TypeError,
  message: 'The first argument must be one of type string or Buffer'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.write.call({ _header: 'test', _hasBody: 'test' }, 1);
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_ARG_TYPE',
  type: TypeError,
  message: 'The first argument must be one of type string or Buffer'
-}));
+});
 
 // addTrailers()
 // The `Error` comes from the JavaScript engine so confirm that it is a
@@ -105,20 +105,20 @@ assert.throws(() => {
  outgoingMessage.addTrailers();
 }, TypeError);
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.addTrailers({ 'あ': 'value' });
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_HTTP_TOKEN',
  type: TypeError,
  message: 'Trailer name must be a valid HTTP token ["あ"]'
-}));
+});
 
-assert.throws(() => {
+common.expectsError(() => {
  const outgoingMessage = new OutgoingMessage();
  outgoingMessage.addTrailers({ 404: 'あ' });
-}, common.expectsError({
+}, {
  code: 'ERR_INVALID_CHAR',
  type: TypeError,
  message: 'Invalid character in trailer content ["404"]'
-}));
+});

test/parallel/test-http2-client-request-options-errors.js

@@ -3,7 +3,6 @@
 const common = require('../common');
 if (!common.hasCrypto)
  common.skip('missing crypto');
-const assert = require('assert');
 const http2 = require('http2');
 
 // Check if correct errors are emitted when wrong type of data is passed
@@ -40,19 +39,19 @@ server.listen(0, common.mustCall(() => {
  return;
  }
 
- assert.throws(
+ common.expectsError(
  () => client.request({
  ':method': 'CONNECT',
  ':authority': `localhost:${port}`
  }, {
  [option]: types[type]
  }),
- common.expectsError({
+ {
  type: TypeError,
  code: 'ERR_INVALID_OPT_VALUE',
  message: `The value "${String(types[type])}" is invalid ` +
  `for option "${option}"`
- })
+ }
  );
  });
  });

test/parallel/test-http2-connect-method.js

@@ -55,36 +55,36 @@ server.listen(0, common.mustCall(() => {
  const client = http2.connect(`http://localhost:${proxy.address().port}`);
 
  // confirm that :authority is required and :scheme & :path are forbidden
- assert.throws(
+ common.expectsError(
  () => client.request({
  [HTTP2_HEADER_METHOD]: 'CONNECT'
  }),
- common.expectsError({
+ {
  code: 'ERR_HTTP2_CONNECT_AUTHORITY',
  message: ':authority header is required for CONNECT requests'
- })
+ }
  );
- assert.throws(
+ common.expectsError(
  () => client.request({
  [HTTP2_HEADER_METHOD]: 'CONNECT',
  [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
  [HTTP2_HEADER_SCHEME]: 'http'
  }),
- common.expectsError({
+ {
  code: 'ERR_HTTP2_CONNECT_SCHEME',
  message: 'The :scheme header is forbidden for CONNECT requests'
- })
+ }
  );
- assert.throws(
+ common.expectsError(
  () => client.request({
  [HTTP2_HEADER_METHOD]: 'CONNECT',
  [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
  [HTTP2_HEADER_PATH]: '/'
  }),
- common.expectsError({
+ {
  code: 'ERR_HTTP2_CONNECT_PATH',
  message: 'The :path header is forbidden for CONNECT requests'
- })
+ }
  );
 
  // valid CONNECT request