test: ensure assertions are reached on all tests

Signed-off-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
PR-URL: #64716
Reviewed-By: Ethan Arrowood <ethan@arrowood.dev>
Reviewed-By: Aviv Keller <me@aviv.sh>

Author: aduh95

test/common/fixtures.mjs

@@ -1,5 +1,6 @@
 import fixtures from './fixtures.js';
 
+// eslint-disable-next-line no-restricted-syntax
 const {
   fixturesDir,
   path,

test/eslint.config_partial.mjs

@@ -117,6 +117,10 @@ export default [
           selector: 'CallExpression:matches([callee.type="Identifier"][callee.name="assert"], [callee.type="MemberExpression"][callee.object.type="Identifier"][callee.object.name="assert"][callee.property.type="Identifier"][callee.property.name="ok"])[arguments.0.type="UnaryExpression"][arguments.0.operator="!"][arguments.0.argument.type="CallExpression"][arguments.0.argument.callee.type="MemberExpression"][arguments.0.argument.callee.object.regex][arguments.0.argument.callee.property.name="test"]',
           message: 'Use assert.doesNotMatch instead',
         },
+        {
+          selector: 'VariableDeclarator[init.type="Identifier"][init.name=/^(assert|fixtures)$/]',
+          message: 'Do not destructure or rename `assert` nor `fixtures`',
+        },
         ...((fixturesSpecifier) => [
           {
             selector: `ImportDeclaration[source.value=${fixturesSpecifier.toString().replace('(\\.js)?', '\\.mjs')}]:not(${[

test/parallel/test-assert-deep.js

@@ -4,7 +4,6 @@ const { mustCall, hasCrypto } = require('../common');
 const assert = require('assert');
 const util = require('util');
 const { test } = require('node:test');
-const { AssertionError } = assert;
 const defaultMsgStart = 'Expected values to be strictly deep-equal:\n';
 const defaultMsgStartFull = `${defaultMsgStart}+ actual - expected`;
 
@@ -688,11 +687,11 @@ test('Handle sparse arrays', () => {
   const b = new Array(3);
   a[2] = true;
   b[1] = true;
-  assertNotDeepOrStrict(a, b, AssertionError, { partial: 'pass' });
+  assertNotDeepOrStrict(a, b, assert.AssertionError, { partial: 'pass' });
   b[2] = true;
   assertNotDeepOrStrict(a, b);
   a[0] = true;
-  assertNotDeepOrStrict(a, b, AssertionError, { partial: 'pass' });
+  assertNotDeepOrStrict(a, b, assert.AssertionError, { partial: 'pass' });
 });
 
 test('Handle sets and maps with mixed keys', () => {
@@ -715,7 +714,7 @@ test('Handle different error messages', () => {
   assertNotDeepOrStrict(err1, new Error('foo2'), assert.AssertionError);
   assertNotDeepOrStrict(err1, new TypeError('foo1'), assert.AssertionError);
   assertDeepAndStrictEqual(err1, new Error('foo1'));
-  assertNotDeepOrStrict(err1, {}, AssertionError);
+  assertNotDeepOrStrict(err1, {}, assert.AssertionError);
 });
 
 test('Handle NaN', () => {
@@ -811,18 +810,18 @@ test('Additional tests', () => {
   assertDeepAndStrictEqual(new Date(2000, 3, 14), new Date(2000, 3, 14));
 
   assert.throws(() => { assert.deepEqual(new Date(), new Date(2000, 3, 14)); },
-                AssertionError,
+                assert.AssertionError,
                 'deepEqual(new Date(), new Date(2000, 3, 14))');
 
   assert.throws(
     () => { assert.notDeepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14)); },
-    AssertionError,
+    assert.AssertionError,
     'notDeepEqual(new Date(2000, 3, 14), new Date(2000, 3, 14))'
   );
 
   assert.throws(
     () => { assert.notDeepEqual('a'.repeat(1024), 'a'.repeat(1024)); },
-    AssertionError,
+    assert.AssertionError,
     'notDeepEqual("a".repeat(1024), "a".repeat(1024))'
   );
 
@@ -861,7 +860,7 @@ test('Additional tests', () => {
   assert.deepEqual(4, '4');
   assert.deepEqual(true, 1);
   assert.throws(() => assert.deepEqual(4, '5'),
-                AssertionError,
+                assert.AssertionError,
                 'deepEqual( 4, \'5\')');
 });
 
@@ -870,7 +869,7 @@ test('Having the same number of owned properties && the same set of keys', () =>
   assert.deepEqual({ a: 4, b: '2' }, { a: 4, b: '2' });
   assert.deepEqual([4], ['4']);
   assert.throws(
-    () => assert.deepEqual({ a: 4 }, { a: 4, b: true }), AssertionError);
+    () => assert.deepEqual({ a: 4 }, { a: 4, b: true }), assert.AssertionError);
   assert.notDeepEqual(['a'], { 0: 'a' });
   assert.deepEqual({ a: 4, b: '1' }, { b: '1', a: 4 });
   const a1 = [1, 2, 3];
@@ -880,7 +879,7 @@ test('Having the same number of owned properties && the same set of keys', () =>
   a2.b = true;
   a2.a = 'test';
   assert.throws(() => assert.deepEqual(Object.keys(a1), Object.keys(a2)),
-                AssertionError);
+                assert.AssertionError);
   assertDeepAndStrictEqual(a1, a2);
 });
 
@@ -946,7 +945,7 @@ test('Additional tests', () => {
 
   assert.throws(
     () => assert.deepStrictEqual(new Date(), new Date(2000, 3, 14)),
-    AssertionError,
+    assert.AssertionError,
     'deepStrictEqual(new Date(), new Date(2000, 3, 14))'
   );
 
@@ -1059,7 +1058,7 @@ test('Additional tests', () => {
 
   assert.throws(
     () => assert.deepStrictEqual([0, 1, 2, 'a', 'b'], [0, 1, 2, 'b', 'a']),
-    AssertionError);
+    assert.AssertionError);
 });
 
 test('Having the same number of owned properties && the same set of keys', () => {
@@ -1105,7 +1104,7 @@ test('Prototype check', () => {
   const obj1 = new Constructor1('Ryan', 'Dahl');
   let obj2 = new Constructor2('Ryan', 'Dahl');
 
-  assert.throws(() => assert.deepStrictEqual(obj1, obj2), AssertionError);
+  assert.throws(() => assert.deepStrictEqual(obj1, obj2), assert.AssertionError);
 
   Constructor2.prototype = Constructor1.prototype;
   obj2 = new Constructor2('Ryan', 'Dahl');
@@ -1262,7 +1261,7 @@ test('Verify that changed tags will still check for the error message', () => {
   err[Symbol.toStringTag] = 'Foobar';
   const err2 = new Error('bar');
   err2[Symbol.toStringTag] = 'Foobar';
-  assertNotDeepOrStrict(err, err2, AssertionError);
+  assertNotDeepOrStrict(err, err2, assert.AssertionError);
 });
 
 test('Check for non-native errors', () => {
@@ -1281,8 +1280,8 @@ test('Check for non-native errors', () => {
 test('Check for Errors with cause property', () => {
   const e1 = new Error('err', { cause: new Error('cause e1') });
   const e2 = new Error('err', { cause: new Error('cause e2') });
-  assertNotDeepOrStrict(e1, e2, AssertionError);
-  assertNotDeepOrStrict(e1, new Error('err'), AssertionError);
+  assertNotDeepOrStrict(e1, e2, assert.AssertionError);
+  assertNotDeepOrStrict(e1, new Error('err'), assert.AssertionError);
   assertDeepAndStrictEqual(e1, new Error('err', { cause: new Error('cause e1') }));
 });
 
@@ -1294,8 +1293,8 @@ test('Check for AggregateError', () => {
   const e3 = new AggregateError([e1duplicate, e2], 'Aggregate Error');
   const e3duplicate = new AggregateError([e1, e2], 'Aggregate Error');
   const e4 = new AggregateError([e1], 'Aggregate Error');
-  assertNotDeepOrStrict(e1, e3, AssertionError);
-  assertNotDeepOrStrict(e3, e4, AssertionError);
+  assertNotDeepOrStrict(e1, e3, assert.AssertionError);
+  assertNotDeepOrStrict(e3, e4, assert.AssertionError);
   assertDeepAndStrictEqual(e3, e3duplicate);
 });
 

test/parallel/test-quic-address-validation.mjs

@@ -9,25 +9,22 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
-const { strictEqual } = assert;
-const { readKey } = fixtures;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
 const { listen, connect, QuicEndpoint } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
-const key = createPrivateKey(readKey('agent1-key.pem'));
-const cert = readKey('agent1-cert.pem');
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
 
 const endpoint = new QuicEndpoint({ validateAddress: true });
 
 const serverEndpoint = await listen(mustCall(async (serverSession) => {
   const info = await serverSession.opened;
   // The handshake should complete despite the Retry flow.
-  strictEqual(info.protocol, 'quic-test');
+  assert.strictEqual(info.protocol, 'quic-test');
   serverSession.close();
 }), {
   endpoint,
@@ -42,7 +39,7 @@ const clientSession = await connect(serverEndpoint.address, {
 });
 
 const info = await clientSession.opened;
-strictEqual(info.protocol, 'quic-test');
+assert.strictEqual(info.protocol, 'quic-test');
 
 // The serverEndpoint must be closed after we wait for the clientSession to close.
 await clientSession.closed;

test/parallel/test-quic-alpn-h3.mjs

@@ -4,18 +4,15 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
-const { strictEqual, notStrictEqual } = assert;
-const { readKey } = fixtures;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
 const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
-const key = createPrivateKey(readKey('agent1-key.pem'));
-const cert = readKey('agent1-cert.pem');
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
 
 // Test h3 ALPN negotiation with Http3ApplicationImpl.
 // Both server and client use the default ALPN (h3).
@@ -24,14 +21,14 @@ const serverOpened = Promise.withResolvers();
 
 const serverEndpoint = await listen(mustCall(async (serverSession) => {
   const info = await serverSession.opened;
-  strictEqual(info.protocol, 'h3');
+  assert.strictEqual(info.protocol, 'h3');
   serverOpened.resolve();
   serverSession.close();
 }), {
   sni: { '*': { keys: [key], certs: [cert] } },
 });
 
-notStrictEqual(serverEndpoint.address, undefined);
+assert.notStrictEqual(serverEndpoint.address, undefined);
 
 const clientSession = await connect(serverEndpoint.address, {
   servername: 'localhost',
@@ -40,7 +37,7 @@ const clientSession = await connect(serverEndpoint.address, {
 
 async function checkClient() {
   const info = await clientSession.opened;
-  strictEqual(info.protocol, 'h3');
+  assert.strictEqual(info.protocol, 'h3');
 }
 
 await Promise.all([serverOpened.promise, checkClient()]);

test/parallel/test-quic-alpn-mismatch.mjs

@@ -8,11 +8,9 @@
 // 0x100 | <tls_alert>. For `no_application_protocol` (alert 120 / 0x78) this
 // is 0x178 == 376.
 
-import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
+import { hasQuic, skip, mustNotCall, expectsError } from '../common/index.mjs';
 import assert from 'node:assert';
 
-const { rejects, strictEqual, match } = assert;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
@@ -25,11 +23,6 @@ const expected = {
   message: /no application protocol/
 };
 
-const onerror = mustCall((err) => {
-  strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR');
-  strictEqual(err.errorCode, 376n);
-  match(err.message, /no application protocol/);
-});
 const transportParams = { maxIdleTimeout: 1 };
 
 // The handshake fails so the session is never surfaced to JS
@@ -43,12 +36,12 @@ const serverEndpoint = await listen(
 const clientSession = await connect(serverEndpoint.address, {
   alpn: 'nonexistent-protocol',
   transportParams,
-  onerror,
+  onerror: expectsError(expected),
 });
 
-await rejects(clientSession.opened, expected);
+await assert.rejects(clientSession.opened, expected);
 
 // The handshake should fail — opened may reject or never resolve.
 // The session should close with an error.
-await rejects(clientSession.closed, expected);
+await assert.rejects(clientSession.closed, expected);
 await serverEndpoint.close();

test/parallel/test-quic-alpn.mjs

@@ -4,18 +4,15 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import * as fixtures from '../common/fixtures.mjs';
 
-const { notStrictEqual, strictEqual } = assert;
-const { readKey } = fixtures;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
 
 const { listen, connect } = await import('node:quic');
 const { createPrivateKey } = await import('node:crypto');
 
-const key = createPrivateKey(readKey('agent1-key.pem'));
-const cert = readKey('agent1-cert.pem');
+const key = createPrivateKey(fixtures.readKey('agent1-key.pem'));
+const cert = fixtures.readKey('agent1-cert.pem');
 
 // Server offers multiple ALPNs. Client requests one that the server supports.
 // Verify the negotiated protocol matches on both sides.
@@ -25,7 +22,7 @@ const serverOpened = Promise.withResolvers();
 async function checkSession(session) {
   const info = await session.opened;
   // The client should negotiate proto-b (the only protocol it requested)
-  strictEqual(info.protocol, 'proto-b');
+  assert.strictEqual(info.protocol, 'proto-b');
 }
 
 const serverEndpoint = await listen(mustCall(async (serverSession) => {
@@ -36,7 +33,7 @@ const serverEndpoint = await listen(mustCall(async (serverSession) => {
   alpn: ['proto-a', 'proto-b', 'proto-c'],
 });
 
-notStrictEqual(serverEndpoint.address, undefined);
+assert.notStrictEqual(serverEndpoint.address, undefined);
 
 const clientSession = await connect(serverEndpoint.address, {
   alpn: 'proto-b',

test/parallel/test-quic-blocklist.mjs

@@ -8,8 +8,6 @@ import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
 import assert from 'node:assert';
 import net from 'node:net';
 
-const { ok, rejects, strictEqual } = assert;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
@@ -34,18 +32,18 @@ const { listen, connect } = await import('../common/quic.mjs');
     handshakeTimeout: 500,
     verifyPeer: 'manual',
     onerror: mustCall((err) => {
-      strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR');
+      assert.strictEqual(err.code, 'ERR_QUIC_TRANSPORT_ERROR');
     }),
   });
 
   // The session should fail — the server never sees the packet.
-  await rejects(clientSession.opened, {
+  await assert.rejects(clientSession.opened, {
     code: 'ERR_QUIC_TRANSPORT_ERROR',
   });
 
   // Verify the stat counter.
-  ok(serverEndpoint.stats.packetsBlocked > 0n,
-     'packetsBlocked should be non-zero');
+  assert.ok(serverEndpoint.stats.packetsBlocked > 0n,
+            'packetsBlocked should be non-zero');
 
   await serverEndpoint.close();
 }
@@ -72,8 +70,7 @@ const { listen, connect } = await import('../common/quic.mjs');
   await clientSession.opened;
   await clientSession.close();
 
-  strictEqual(serverEndpoint.stats.packetsBlocked, 0n,
-              'No packets should be blocked for allowed address');
+  assert.strictEqual(serverEndpoint.stats.packetsBlocked, 0n); // No packets should be blocked for allowed address
 
   await serverEndpoint.close();
 }

test/parallel/test-quic-callback-error-onblocked.mjs

@@ -7,8 +7,6 @@
 import { hasQuic, skip, mustCall } from '../common/index.mjs';
 import assert from 'node:assert';
 
-const { rejects } = assert;
-
 if (!hasQuic) {
   skip('QUIC is not enabled');
 }
@@ -42,5 +40,5 @@ stream.onblocked = mustCall(() => {
 stream.setBody(new Uint8Array(4096));
 
 // The stream's closed promise should reject with the error from the throw.
-await rejects(stream.closed, testError);
+await assert.rejects(stream.closed, testError);
 await serverEndpoint.close();