test: ensure assertions are reached on more tests

Author: aduh95

test/addons/callback-scope/test-async-hooks.js

@@ -17,6 +17,6 @@ async_hooks.createHook({
   }),
 }).enable();
 
-runInCallbackScope({}, 1000, 1000, () => {
+runInCallbackScope({}, 1000, 1000, common.mustCallAtLeast(() => {
   assert(insideHook);
-});
+}));

test/addons/callback-scope/test-resolve-async.js

@@ -9,4 +9,4 @@ const { testResolveAsync } = require(`./build/${common.buildType}/binding`);
 let called = false;
 testResolveAsync().then(() => { called = true; });
 
-process.on('beforeExit', () => { assert(called); });
+process.on('beforeExit', common.mustCall(() => { assert(called); }));

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

@@ -9,13 +9,13 @@ const server = http.createServer((req, res) => {
   res.end('ok');
 });
 
-server.listen(0, () => {
-  asyncLocalStorage.run(new Map(), () => {
+server.listen(0, mustCall(() => {
+  asyncLocalStorage.run(new Map(), mustCall(() => {
     const store = asyncLocalStorage.getStore();
     store.set('hello', 'world');
     http.get({ host: 'localhost', port: server.address().port }, mustCall(() => {
       assert.strictEqual(asyncLocalStorage.getStore().get('hello'), 'world');
       server.close();
     }));
-  });
-});
+  }));
+}));

test/eslint.config_partial.mjs

@@ -194,7 +194,7 @@ export default [
       ].join(',')}}/**/*.{js,mjs,cjs}`,
       `test/parallel/test-{${
         // 0x61 is code for 'a', this generates a string enumerating latin letters: 'a*,b*,…'
-        Array.from({ length: 3 }, (_, i) => String.fromCharCode(0x61 + i, 42)).join(',')
+        Array.from({ length: 4 }, (_, i) => String.fromCharCode(0x61 + i, 42)).join(',')
       },${
         // 0x61 is code for 'a', this generates a string enumerating latin letters: 'z*,y*,…'
         Array.from({ length: 2 }, (_, i) => String.fromCharCode(0x61 + 25 - i, 42)).join(',')

test/module-hooks/test-module-hooks-custom-conditions-cjs.js

@@ -5,6 +5,7 @@ const common = require('../common');
 const { registerHooks } = require('node:module');
 const assert = require('node:assert');
 const { cjs, esm } = require('../fixtures/es-modules/custom-condition/load.cjs');
+const { mustCall } = require('../common/index.mjs');
 
 (async () => {
   // Without hooks, the default condition is used.
@@ -15,11 +16,11 @@ const { cjs, esm } = require('../fixtures/es-modules/custom-condition/load.cjs')
   // allow a CJS to be resolved with that condition.
   {
     const hooks = registerHooks({
-      resolve(specifier, context, nextResolve) {
+      resolve: mustCall((specifier, context, nextResolve) => {
         assert(Array.isArray(context.conditions));
         context.conditions = ['foo', ...context.conditions];
         return nextResolve(specifier, context);
-      },
+      }, 2),
     });
     assert.strictEqual(cjs('foo/second').result, 'foo');
     assert.strictEqual((await esm('foo/second')).result, 'foo');
@@ -30,11 +31,11 @@ const { cjs, esm } = require('../fixtures/es-modules/custom-condition/load.cjs')
   // allow a ESM to be resolved with that condition.
   {
     const hooks = registerHooks({
-      resolve(specifier, context, nextResolve) {
+      resolve: mustCall((specifier, context, nextResolve) => {
         assert(Array.isArray(context.conditions));
         context.conditions = ['foo-esm', ...context.conditions];
         return nextResolve(specifier, context);
-      },
+      }, 2),
     });
     assert.strictEqual(cjs('foo/third').result, 'foo-esm');
     assert.strictEqual((await esm('foo/third')).result, 'foo-esm');
@@ -44,11 +45,11 @@ const { cjs, esm } = require('../fixtures/es-modules/custom-condition/load.cjs')
   // Duplicating the 'foo' condition in the resolve hook should not change the result.
   {
     const hooks = registerHooks({
-      resolve(specifier, context, nextResolve) {
+      resolve: mustCall((specifier, context, nextResolve) => {
         assert(Array.isArray(context.conditions));
         context.conditions = ['foo', ...context.conditions, 'foo'];
         return nextResolve(specifier, context);
-      },
+      }, 2),
     });
     assert.strictEqual(cjs('foo/fourth').result, 'foo');
     assert.strictEqual((await esm('foo/fourth')).result, 'foo');

test/module-hooks/test-module-hooks-custom-conditions.mjs

@@ -1,5 +1,5 @@
 // This tests that custom conditions can be used in module resolution hooks.
-import '../common/index.mjs';
+import * as common from '../common/index.mjs';
 import { registerHooks } from 'node:module';
 import assert from 'node:assert';
 import { cjs, esm } from '../fixtures/es-modules/custom-condition/load.cjs';
@@ -12,11 +12,11 @@ assert.strictEqual((await esm('foo')).result, 'default');
 // allow a CJS to be resolved with that condition.
 {
   const hooks = registerHooks({
-    resolve(specifier, context, nextResolve) {
+    resolve: common.mustCall((specifier, context, nextResolve) => {
       assert(Array.isArray(context.conditions));
       context.conditions = ['foo', ...context.conditions];
       return nextResolve(specifier, context);
-    },
+    }, 2),
   });
   assert.strictEqual(cjs('foo/second').result, 'foo');
   assert.strictEqual((await esm('foo/second')).result, 'foo');
@@ -27,11 +27,11 @@ assert.strictEqual((await esm('foo')).result, 'default');
 // allow a ESM to be resolved with that condition.
 {
   const hooks = registerHooks({
-    resolve(specifier, context, nextResolve) {
+    resolve: common.mustCall((specifier, context, nextResolve) => {
       assert(Array.isArray(context.conditions));
       context.conditions = ['foo-esm', ...context.conditions];
       return nextResolve(specifier, context);
-    },
+    }, 2),
   });
   assert.strictEqual(cjs('foo/third').result, 'foo-esm');
   assert.strictEqual((await esm('foo/third')).result, 'foo-esm');
@@ -41,11 +41,11 @@ assert.strictEqual((await esm('foo')).result, 'default');
 // Duplicating the 'foo' condition in the resolve hook should not change the result.
 {
   const hooks = registerHooks({
-    resolve(specifier, context, nextResolve) {
+    resolve: common.mustCall((specifier, context, nextResolve) => {
       assert(Array.isArray(context.conditions));
       context.conditions = ['foo', ...context.conditions, 'foo'];
       return nextResolve(specifier, context);
-    },
+    }, 2),
   });
   assert.strictEqual(cjs('foo/fourth').result, 'foo');
   assert.strictEqual((await esm('foo/fourth')).result, 'foo');

test/node-api/test_callback_scope/test-async-hooks.js

@@ -34,6 +34,6 @@ async_hooks.createHook({
   }),
 }).enable();
 
-runInCallbackScope(expectedResource, expectedResourceType, () => {
+runInCallbackScope(expectedResource, expectedResourceType, common.mustCall(() => {
   assert(insideHook);
-});
+}));

test/parallel/test-assert.js

@@ -21,7 +21,7 @@
 
 'use strict';
 
-const { invalidArgTypeHelper } = require('../common');
+const { invalidArgTypeHelper, mustCall } = require('../common');
 const assert = require('assert');
 const { inspect } = require('util');
 const { test } = require('node:test');
@@ -605,7 +605,7 @@ test('Test strict assert', () => {
     }
   );
   strict.throws(
-    () => assert(),
+    mustCall(() => assert()),
     {
       message: 'No value argument passed to `assert.ok()`',
       name: 'AssertionError'

test/parallel/test-child-process-fork-net.js

@@ -172,12 +172,12 @@ if (process.argv[2] === 'child') {
   function closeServer() {
     server.close();
 
-    setTimeout(() => {
+    setTimeout(mustCall(() => {
       assert(!closeEmitted);
       child1.send('close');
       child2.send('close');
       child3.disconnect();
-    }, platformTimeout(200));
+    }), platformTimeout(200));
   }
 
   process.on('exit', function() {

test/parallel/test-cluster-basic.js

@@ -160,36 +160,36 @@ if (cluster.isWorker) {
   }));
 
   // Check all values
-  process.once('exit', () => {
+  process.on('exit', () => {
     // Check cluster events
-    forEach(checks.cluster.events, (check, name) => {
+    for (const [ name, check ] of Object.entries(checks.cluster.events)) {
       assert(check,
              `The cluster event "${name}" on the cluster object did not fire`);
-    });
+    }
 
     // Check cluster event arguments
-    forEach(checks.cluster.equal, (check, name) => {
+    for (const [ name, check ] of Object.entries(checks.cluster.equal)) {
       assert(check,
              `The cluster event "${name}" did not emit with correct argument`);
-    });
+    }
 
     // Check worker states
-    forEach(checks.worker.states, (check, name) => {
+    for (const [ name, check ] of Object.entries(checks.worker.states)) {
       assert(check,
              `The worker state "${name}" was not set to true`);
-    });
+    }
 
     // Check worker events
-    forEach(checks.worker.events, (check, name) => {
+    for (const [ name, check ] of Object.entries(checks.worker.events)) {
       assert(check,
              `The worker event "${name}" on the worker object did not fire`);
-    });
+    }
 
     // Check worker event arguments
-    forEach(checks.worker.equal, (check, name) => {
+    for (const [ name, check ] of Object.entries(checks.worker.equal)) {
       assert(check,
              `The worker event "${name}" did not emit with correct argument`);
-    });
+    }
   });
 
 }