test: ensure assertions are reachable in test/async-hooks

PR-URL: #60150
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>

Author: aduh95

test/async-hooks/hook-checks.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 
 /**
@@ -15,7 +15,7 @@ const assert = require('assert');
  * @param {string} stage the name of the stage in the test at which we are
  * checking the invocations
  */
-exports.checkInvocations=functioncheckInvocations(activity,hooks,stage){
+exports.checkInvocations=common.mustCallAtLeast(functioncheckInvocations(activity,hooks,stage){
 conststageInfo=`Checking invocations at stage "${stage}":\n `;
 
 assert.ok(activity!=null,
@@ -24,9 +24,7 @@ exports.checkInvocations = function checkInvocations(activity, hooks, stage) {
 );
 
 // Check that actual invocations for all hooks match the expected invocations
-['init','before','after','destroy','promiseResolve'].forEach(checkHook);
-
-functioncheckHook(k){
+['init','before','after','destroy','promiseResolve'].forEach((k)=>{
 constval=hooks[k];
 // Not expected ... all good
 if(val==null)return;
@@ -49,5 +47,5 @@ exports.checkInvocations = function checkInvocations(activity, hooks, stage) {
 `time(s), but expected ${val} invocation(s).`;
 assert.strictEqual(activity[k].length,val,msg2);
 }
-}
-};
+});
+},0);

test/async-hooks/test-async-exec-resource-http-32060.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{
  executionAsyncResource,
@@ -22,16 +22,16 @@ const server = http.createServer((req, res) => {
 },1000);
 });
 
-server.listen(0,()=>{
+server.listen(0,common.mustCallAtLeast(()=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
-http.get({port: server.address().port},(res)=>{
+http.get({port: server.address().port},common.mustCallAtLeast((res)=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
-res.on('data',()=>{
+res.on('data',common.mustCallAtLeast(()=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
-});
-res.on('end',()=>{
+}));
+res.on('end',common.mustCall(()=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
 server.close();
-});
-});
-});
+}));
+}));
+}));

test/async-hooks/test-async-exec-resource-http.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{
  executionAsyncResource,
@@ -20,11 +20,11 @@ const server = http.createServer((req, res) => {
 res.end('ok');
 });
 
-server.listen(0,()=>{
+server.listen(0,common.mustCall(()=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
 
-http.get({port: server.address().port},()=>{
+http.get({port: server.address().port},common.mustCall(()=>{
 assert.strictEqual(executionAsyncResource(),hooked[executionAsyncId()]);
 server.close();
-});
-});
+}));
+}));

test/async-hooks/test-async-local-storage-args.js

@@ -1,13 +1,13 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{ AsyncLocalStorage }=require('async_hooks');
 
 constasyncLocalStorage=newAsyncLocalStorage();
 
-asyncLocalStorage.run({},(runArg)=>{
+asyncLocalStorage.run({},common.mustCall((runArg)=>{
 assert.strictEqual(runArg,'foo');
-asyncLocalStorage.exit((exitArg)=>{
+asyncLocalStorage.exit(common.mustCall((exitArg)=>{
 assert.strictEqual(exitArg,'bar');
-},'bar');
-},'foo');
+}),'bar');
+}),'foo');

test/async-hooks/test-async-local-storage-dgram.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+constcommon=require('../common');
 
 // Regression tests for https://github.com/nodejs/node/issues/40693
 
@@ -10,17 +10,17 @@ const { AsyncLocalStorage } = require('async_hooks');
 
 dgram.createSocket('udp4')
 .on('message',function(msg,rinfo){this.send(msg,rinfo.port);})
-.on('listening',function(){
+.on('listening',common.mustCall(function(){
 constasyncLocalStorage=newAsyncLocalStorage();
 conststore={val: 'abcd'};
-asyncLocalStorage.run(store,()=>{
+asyncLocalStorage.run(store,common.mustCall(()=>{
 constclient=dgram.createSocket('udp4');
-client.on('message',(msg,rinfo)=>{
+client.on('message',common.mustCall((msg,rinfo)=>{
 assert.deepStrictEqual(asyncLocalStorage.getStore(),store);
 client.close();
 this.close();
-});
+}));
 client.send('Hello, world!',this.address().port);
-});
-})
+}));
+}))
 .bind(0);

test/async-hooks/test-async-local-storage-enable-disable.js

@@ -1,11 +1,11 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{ AsyncLocalStorage }=require('async_hooks');
 
 constasyncLocalStorage=newAsyncLocalStorage();
 
-asyncLocalStorage.run(newMap(),()=>{
+asyncLocalStorage.run(newMap(),common.mustCall(()=>{
 asyncLocalStorage.getStore().set('foo','bar');
 process.nextTick(()=>{
 assert.strictEqual(asyncLocalStorage.getStore().get('foo'),'bar');
@@ -17,16 +17,16 @@ asyncLocalStorage.run(new Map(), () => {
 assert.strictEqual(asyncLocalStorage.getStore(),undefined);
 
 // Calls to exit() should not mess with enabled status
-asyncLocalStorage.exit(()=>{
+asyncLocalStorage.exit(common.mustCall(()=>{
 assert.strictEqual(asyncLocalStorage.getStore(),undefined);
-});
+}));
 assert.strictEqual(asyncLocalStorage.getStore(),undefined);
 
 process.nextTick(()=>{
 assert.strictEqual(asyncLocalStorage.getStore(),undefined);
-asyncLocalStorage.run(newMap().set('bar','foo'),()=>{
+asyncLocalStorage.run(newMap().set('bar','foo'),common.mustCall(()=>{
 assert.strictEqual(asyncLocalStorage.getStore().get('bar'),'foo');
-});
+}));
 });
 });
-});
+}));

test/async-hooks/test-async-local-storage-enter-with.js

@@ -1,20 +1,20 @@
 'use strict';
-require('../common');
+constcommon=require('../common');
 constassert=require('assert');
 const{ AsyncLocalStorage }=require('async_hooks');
 
 constasyncLocalStorage=newAsyncLocalStorage();
 
-setImmediate(()=>{
+setImmediate(common.mustCall(()=>{
 conststore={foo: 'bar'};
 asyncLocalStorage.enterWith(store);
 
 assert.strictEqual(asyncLocalStorage.getStore(),store);
-setTimeout(()=>{
+setTimeout(common.mustCall(()=>{
 assert.strictEqual(asyncLocalStorage.getStore(),store);
-},10);
-});
+}),10);
+}));
 
-setTimeout(()=>{
+setTimeout(common.mustCall(()=>{
 assert.strictEqual(asyncLocalStorage.getStore(),undefined);
-},10);
+}),10);

test/async-hooks/test-async-local-storage-gcable.js

@@ -11,11 +11,11 @@ const { onGC } = require('../common/gc');
 
 letasyncLocalStorage=newAsyncLocalStorage();
 
-asyncLocalStorage.run({},()=>{
+asyncLocalStorage.run({},common.mustCall(()=>{
 asyncLocalStorage.disable();
 
 onGC(asyncLocalStorage,{ongc: common.mustCall()});
-});
+}));
 
 if(AsyncContextFrame.enabled){
 // This disable() is needed to remove reference form AsyncContextFrame

test/async-hooks/test-async-local-storage-http-agent.js

@@ -21,7 +21,7 @@ server.listen(0, common.mustCall(() => {
 constport=server.address().port;
 
 for(leti=0;i<N;i++){
-asyncLocalStorage.run(i,()=>{
+asyncLocalStorage.run(i,common.mustCall(()=>{
 http.get({ agent, port },common.mustCall((res)=>{
 assert.strictEqual(asyncLocalStorage.getStore(),i);
 if(++responses===N){
@@ -30,6 +30,6 @@ server.listen(0, common.mustCall(() => {
 }
 res.resume();
 }));
-});
+}));
 }
 }));

test/async-hooks/test-async-local-storage-http.js

@@ -1,5 +1,5 @@
 'use strict';
-require('../common');
+const{ mustCall }=require('../common');
 constassert=require('assert');
 const{ AsyncLocalStorage }=require('async_hooks');
 consthttp=require('http');
@@ -13,9 +13,9 @@ server.listen(0, () => {
 asyncLocalStorage.run(newMap(),()=>{
 conststore=asyncLocalStorage.getStore();
 store.set('hello','world');
-http.get({host: 'localhost',port: server.address().port},()=>{
+http.get({host: 'localhost',port: server.address().port},mustCall(()=>{
 assert.strictEqual(asyncLocalStorage.getStore().get('hello'),'world');
 server.close();
-});
+}));
 });
 });