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 @@
 importfixturesfrom'./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');
 constassert=require('assert');
 constutil=require('util');
 const{ test }=require('node:test');
-const{ AssertionError }=assert;
 constdefaultMsgStart='Expected values to be strictly deep-equal:\n';
 constdefaultMsgStartFull=`${defaultMsgStart}+ actual - expected`;
 
@@ -688,11 +687,11 @@ test('Handle sparse arrays', () => {
 constb=newArray(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,newError('foo2'),assert.AssertionError);
 assertNotDeepOrStrict(err1,newTypeError('foo1'),assert.AssertionError);
 assertDeepAndStrictEqual(err1,newError('foo1'));
-assertNotDeepOrStrict(err1,{},AssertionError);
+assertNotDeepOrStrict(err1,{},assert.AssertionError);
 });
 
 test('Handle NaN',()=>{
@@ -811,18 +810,18 @@ test('Additional tests', () => {
 assertDeepAndStrictEqual(newDate(2000,3,14),newDate(2000,3,14));
 
 assert.throws(()=>{assert.deepEqual(newDate(),newDate(2000,3,14));},
-AssertionError,
+assert.AssertionError,
 'deepEqual(new Date(), new Date(2000, 3, 14))');
 
 assert.throws(
 ()=>{assert.notDeepEqual(newDate(2000,3,14),newDate(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});
 consta1=[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(newDate(),newDate(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', () => {
 constobj1=newConstructor1('Ryan','Dahl');
 letobj2=newConstructor2('Ryan','Dahl');
 
-assert.throws(()=>assert.deepStrictEqual(obj1,obj2),AssertionError);
+assert.throws(()=>assert.deepStrictEqual(obj1,obj2),assert.AssertionError);
 
 Constructor2.prototype=Constructor1.prototype;
 obj2=newConstructor2('Ryan','Dahl');
@@ -1262,7 +1261,7 @@ test('Verify that changed tags will still check for the error message', () => {
 err[Symbol.toStringTag]='Foobar';
 consterr2=newError('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',()=>{
 conste1=newError('err',{cause: newError('cause e1')});
 conste2=newError('err',{cause: newError('cause e2')});
-assertNotDeepOrStrict(e1,e2,AssertionError);
-assertNotDeepOrStrict(e1,newError('err'),AssertionError);
+assertNotDeepOrStrict(e1,e2,assert.AssertionError);
+assertNotDeepOrStrict(e1,newError('err'),assert.AssertionError);
 assertDeepAndStrictEqual(e1,newError('err',{cause: newError('cause e1')}));
 });
 
@@ -1294,8 +1293,8 @@ test('Check for AggregateError', () => {
 conste3=newAggregateError([e1duplicate,e2],'Aggregate Error');
 conste3duplicate=newAggregateError([e1,e2],'Aggregate Error');
 conste4=newAggregateError([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';
 importassertfrom'node:assert';
 import*asfixturesfrom'../common/fixtures.mjs';
 
-const{ strictEqual }=assert;
-const{ readKey }=fixtures;
-
 if(!hasQuic){
 skip('QUIC is not enabled');
 }
 
 const{ listen, connect, QuicEndpoint }=awaitimport('node:quic');
 const{ createPrivateKey }=awaitimport('node:crypto');
 
-constkey=createPrivateKey(readKey('agent1-key.pem'));
-constcert=readKey('agent1-cert.pem');
+constkey=createPrivateKey(fixtures.readKey('agent1-key.pem'));
+constcert=fixtures.readKey('agent1-cert.pem');
 
 constendpoint=newQuicEndpoint({validateAddress: true});
 
 constserverEndpoint=awaitlisten(mustCall(async(serverSession)=>{
 constinfo=awaitserverSession.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, {
 });
 
 constinfo=awaitclientSession.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.
 awaitclientSession.closed;

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

@@ -4,18 +4,15 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs';
 importassertfrom'node:assert';
 import*asfixturesfrom'../common/fixtures.mjs';
 
-const{ strictEqual, notStrictEqual }=assert;
-const{ readKey }=fixtures;
-
 if(!hasQuic){
 skip('QUIC is not enabled');
 }
 
 const{ listen, connect }=awaitimport('node:quic');
 const{ createPrivateKey }=awaitimport('node:crypto');
 
-constkey=createPrivateKey(readKey('agent1-key.pem'));
-constcert=readKey('agent1-cert.pem');
+constkey=createPrivateKey(fixtures.readKey('agent1-key.pem'));
+constcert=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();
 
 constserverEndpoint=awaitlisten(mustCall(async(serverSession)=>{
 constinfo=awaitserverSession.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);
 
 constclientSession=awaitconnect(serverEndpoint.address,{
 servername: 'localhost',
@@ -40,7 +37,7 @@ const clientSession = await connect(serverEndpoint.address, {
 
 asyncfunctioncheckClient(){
 constinfo=awaitclientSession.opened;
-strictEqual(info.protocol,'h3');
+assert.strictEqual(info.protocol,'h3');
 }
 
 awaitPromise.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';
 importassertfrom'node:assert';
 
-const{ rejects, strictEqual, match }=assert;
-
 if(!hasQuic){
 skip('QUIC is not enabled');
 }
@@ -25,11 +23,6 @@ const expected = {
 message: /noapplicationprotocol/
 };
 
-constonerror=mustCall((err)=>{
-strictEqual(err.code,'ERR_QUIC_TRANSPORT_ERROR');
-strictEqual(err.errorCode,376n);
-match(err.message,/noapplicationprotocol/);
-});
 consttransportParams={maxIdleTimeout: 1};
 
 // The handshake fails so the session is never surfaced to JS
@@ -43,12 +36,12 @@ const serverEndpoint = await listen(
 constclientSession=awaitconnect(serverEndpoint.address,{
 alpn: 'nonexistent-protocol',
  transportParams,
- onerror,
+onerror: expectsError(expected),
 });
 
-awaitrejects(clientSession.opened,expected);
+awaitassert.rejects(clientSession.opened,expected);
 
 // The handshake should fail — opened may reject or never resolve.
 // The session should close with an error.
-awaitrejects(clientSession.closed,expected);
+awaitassert.rejects(clientSession.closed,expected);
 awaitserverEndpoint.close();

test/parallel/test-quic-alpn.mjs

@@ -4,18 +4,15 @@ import { hasQuic, skip, mustCall } from '../common/index.mjs';
 importassertfrom'node:assert';
 import*asfixturesfrom'../common/fixtures.mjs';
 
-const{ notStrictEqual, strictEqual }=assert;
-const{ readKey }=fixtures;
-
 if(!hasQuic){
 skip('QUIC is not enabled');
 }
 
 const{ listen, connect }=awaitimport('node:quic');
 const{ createPrivateKey }=awaitimport('node:crypto');
 
-constkey=createPrivateKey(readKey('agent1-key.pem'));
-constcert=readKey('agent1-cert.pem');
+constkey=createPrivateKey(fixtures.readKey('agent1-key.pem'));
+constcert=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();
 asyncfunctioncheckSession(session){
 constinfo=awaitsession.opened;
 // The client should negotiate proto-b (the only protocol it requested)
-strictEqual(info.protocol,'proto-b');
+assert.strictEqual(info.protocol,'proto-b');
 }
 
 constserverEndpoint=awaitlisten(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);
 
 constclientSession=awaitconnect(serverEndpoint.address,{
 alpn: 'proto-b',

test/parallel/test-quic-blocklist.mjs

@@ -8,8 +8,6 @@ import { hasQuic, skip, mustCall, mustNotCall } from '../common/index.mjs';
 importassertfrom'node:assert';
 importnetfrom'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.
-awaitrejects(clientSession.opened,{
+awaitassert.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');
 
 awaitserverEndpoint.close();
 }
@@ -72,8 +70,7 @@ const { listen, connect } = await import('../common/quic.mjs');
 awaitclientSession.opened;
 awaitclientSession.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
 
 awaitserverEndpoint.close();
 }

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

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