test: ensure assertions are reached on more tests

PR-URL: #60634
Reviewed-By: Colin Ihrig <[email protected]>

Author: aduh95

test/eslint.config_partial.mjs

@@ -197,7 +197,7 @@ export default [
         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(',')
+        Array.from({ length: 5 }, (_, i) => String.fromCharCode(0x61 + 25 - i, 42)).join(',')
       }}.{js,mjs,cjs}`,
     ],
     rules: {

test/parallel/test-vfs.js

@@ -6,7 +6,7 @@ const common = require('../common');
 const Module = require('module');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
-const { deepStrictEqual, ok, strictEqual, throws } = require('assert');
+const assert = require('assert');
 const { join } = require('path');
 
 const directory = tmpdir.resolve('directory');
@@ -17,20 +17,20 @@ tmpdir.refresh();
 fs.writeFileSync(file, "module.exports = { a: 'b' }");
 fs.mkdirSync(directory);
 
-strictEqual(Module._stat(directory), 1);
-ok(Module._stat(doesNotExist) < 0);
-strictEqual(Module._stat(file), 0);
+assert.strictEqual(Module._stat(directory), 1);
+assert.ok(Module._stat(doesNotExist) < 0);
+assert.strictEqual(Module._stat(file), 0);
 
 const vfsDirectory = join(process.execPath, 'directory');
 const vfsDoesNotExist = join(process.execPath, 'does-not-exist');
 const vfsFile = join(process.execPath, 'file.js');
 
-ok(Module._stat(vfsDirectory) < 0);
-ok(Module._stat(vfsDoesNotExist) < 0);
-ok(Module._stat(vfsFile) < 0);
+assert.ok(Module._stat(vfsDirectory) < 0);
+assert.ok(Module._stat(vfsDoesNotExist) < 0);
+assert.ok(Module._stat(vfsFile) < 0);
 
-deepStrictEqual(require(file), { a: 'b' });
-throws(() => require(vfsFile), { code: 'MODULE_NOT_FOUND' });
+assert.deepStrictEqual(require(file), { a: 'b' });
+assert.throws(() => require(vfsFile), { code: 'MODULE_NOT_FOUND' });
 
 common.expectWarning(
   'ExperimentalWarning',
@@ -75,15 +75,15 @@ fs.realpathSync = function realpathSync(pathArgument, options) {
   return pathArgument;
 };
 
-strictEqual(Module._stat(directory), 1);
-ok(Module._stat(doesNotExist) < 0);
-strictEqual(Module._stat(file), 0);
+assert.strictEqual(Module._stat(directory), 1);
+assert.ok(Module._stat(doesNotExist) < 0);
+assert.strictEqual(Module._stat(file), 0);
 
-strictEqual(Module._stat(vfsDirectory), 1);
-ok(Module._stat(vfsDoesNotExist) < 0);
-strictEqual(Module._stat(vfsFile), 0);
+assert.strictEqual(Module._stat(vfsDirectory), 1);
+assert.ok(Module._stat(vfsDoesNotExist) < 0);
+assert.strictEqual(Module._stat(vfsFile), 0);
 
-strictEqual(Module._stat(process.execPath), 1);
+assert.strictEqual(Module._stat(process.execPath), 1);
 
-deepStrictEqual(require(file), { a: 'b' });
-deepStrictEqual(require(vfsFile), { x: 'y' });
+assert.deepStrictEqual(require(file), { a: 'b' });
+assert.deepStrictEqual(require(vfsFile), { x: 'y' });

test/parallel/test-vm-module-basic.js

@@ -166,13 +166,13 @@ const util = require('util');
   const module = new SyntheticModule([], () => {});
   module.link(() => {});
   const f = compileFunction('return import("x")', [], {
-    importModuleDynamically(specifier, referrer) {
+    importModuleDynamically: common.mustCall((specifier, referrer) => {
       assert.strictEqual(specifier, 'x');
       assert.strictEqual(referrer, f);
       return module;
-    },
+    }),
   });
   f().then((ns) => {
     assert.strictEqual(ns, module.namespace);
-  });
+  }).then(common.mustCall());
 }

test/parallel/test-vm-module-link.js

@@ -144,15 +144,15 @@ async function asserts() {
   const m = new SourceTextModule(`
   import "foo" with { n1: 'v1', n2: 'v2' };
   `, { identifier: 'm' });
-  await m.link((s, r, p) => {
+  await m.link(common.mustCall((s, r, p) => {
     assert.strictEqual(s, 'foo');
     assert.strictEqual(r.identifier, 'm');
     assert.strictEqual(p.attributes.n1, 'v1');
     assert.strictEqual(p.assert.n1, 'v1');
     assert.strictEqual(p.attributes.n2, 'v2');
     assert.strictEqual(p.assert.n2, 'v2');
     return new SourceTextModule('');
-  });
+  }));
 }
 
 const finished = common.mustCall();

test/parallel/test-wasm.mjs

@@ -1,5 +1,5 @@
 import '../common/index.mjs';
-import { strictEqual } from 'node:assert';
+import assert from 'node:assert';
 import { readSync } from '../common/fixtures.mjs';
 
 // Test Wasm JSPI
@@ -40,5 +40,5 @@ import { readSync } from '../common/fixtures.mjs';
   });
 
   const promisingExport = WebAssembly.promising(instance.exports.test);
-  strictEqual(await promisingExport(10), 52);
+  assert.strictEqual(await promisingExport(10), 52);
 }

test/parallel/test-watch-file-shared-dependency.mjs

@@ -34,15 +34,15 @@ describe('watch file with shared dependency', () => {
     const controller = new AbortController();
     const watcher = new FilesWatcher({ signal: controller.signal });
 
-    watcher.on('changed', ({ owners }) => {
+    watcher.on('changed', common.mustCall(({ owners }) => {
       if (owners.size !== 2) return;
 
       // If this code is never reached the test times out.
       assert.ok(owners.has(fixturePaths['test.js']));
       assert.ok(owners.has(fixturePaths['test-2.js']));
       controller.abort();
       done();
-    });
+    }));
     watcher.filterFile(fixturePaths['test.js']);
     watcher.filterFile(fixturePaths['test-2.js']);
     watcher.filterFile(fixturePaths['dependency.js'], fixturePaths['test.js']);

test/parallel/test-weakref.js

@@ -2,12 +2,12 @@
 
 // Flags: --expose-gc
 
-require('../common');
+const common = require('../common');
 const assert = require('assert');
 
 const w = new globalThis.WeakRef({});
 
-setTimeout(() => {
+setTimeout(common.mustCall(() => {
   globalThis.gc();
   assert.strictEqual(w.deref(), undefined);
-}, 200);
+}), 200);

test/parallel/test-web-locks-query.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const { describe, it } = require('node:test');
 const assert = require('node:assert');
 const { Worker } = require('worker_threads');
@@ -26,7 +26,7 @@ describe('Web Locks - query missing WPT tests', () => {
       worker.once('message', resolve);
     });
 
-    await navigator.locks.request('different-contexts-resource', { mode: 'shared' }, async (lock) => {
+    await navigator.locks.request('different-contexts-resource', { mode: 'shared' }, common.mustCall(async (lock) => {
       const state = await navigator.locks.query();
       const heldLocks = state.held.filter((l) => l.name === 'different-contexts-resource');
 
@@ -35,7 +35,7 @@ describe('Web Locks - query missing WPT tests', () => {
       assert.notStrictEqual(mainClientId, workerResult.clientId);
 
       worker.postMessage('release');
-    });
+    }));
 
     await worker.terminate();
   });
@@ -67,7 +67,7 @@ describe('Web Locks - query missing WPT tests', () => {
     });
     assert.strictEqual(step1.acquired, 'resource1');
 
-    await navigator.locks.request('deadlock-resource-2', async (lock2) => {
+    await navigator.locks.request('deadlock-resource-2', common.mustCall(async (lock2) => {
       worker.postMessage('try-resource2');
 
       const step2 = await new Promise((resolve) => {
@@ -85,7 +85,7 @@ describe('Web Locks - query missing WPT tests', () => {
       assert(resource2Lock);
 
       worker.postMessage('release');
-    });
+    }));
 
     await worker.terminate();
   });

test/parallel/test-web-locks.js

@@ -26,10 +26,10 @@ describe('Web Locks with worker threads', () => {
     assert.strictEqual(result.success, true);
     await worker.terminate();
 
-    await navigator.locks.request('exclusive-test', async (lock) => {
+    await navigator.locks.request('exclusive-test', common.mustCall(async (lock) => {
       assert.strictEqual(lock.mode, 'exclusive');
       assert.strictEqual(lock.name, 'exclusive-test');
-    });
+    }));
   });
 
   it('should handle shared locks', async () => {
@@ -48,41 +48,43 @@ describe('Web Locks with worker threads', () => {
     });
     assert.strictEqual(result.success, true);
 
-    await navigator.locks.request('shared-test', { mode: 'shared' }, async (lock1) => {
-      await navigator.locks.request('shared-test', { mode: 'shared' }, async (lock2) => {
+    await navigator.locks.request('shared-test', { mode: 'shared' }, common.mustCall(async (lock1) => {
+      await navigator.locks.request('shared-test', { mode: 'shared' }, common.mustCall(async (lock2) => {
         assert.strictEqual(lock1.mode, 'shared');
         assert.strictEqual(lock2.mode, 'shared');
-      });
-    });
+      }));
+    }));
 
     await worker.terminate();
   });
 
   it('should handle steal option - no existing lock', async () => {
-    await navigator.locks.request('steal-simple', { steal: true }, async (lock) => {
+    await navigator.locks.request('steal-simple', { steal: true }, common.mustCall(async (lock) => {
       assert.strictEqual(lock.name, 'steal-simple');
       assert.strictEqual(lock.mode, 'exclusive');
-    });
+    }));
   });
 
   it('should handle steal option - existing lock', async () => {
     let originalLockRejected = false;
 
-    const originalLockPromise = navigator.locks.request('steal-target', async (lock) => {
+    const originalLockPromise = navigator.locks.request('steal-target', common.mustCall(async (lock) => {
       assert.strictEqual(lock.name, 'steal-target');
       return 'original-completed';
-    }).catch((err) => {
+    })).catch(common.mustCall((err) => {
       originalLockRejected = true;
       assert.strictEqual(err.name, 'AbortError');
       assert.strictEqual(err.message, 'The operation was aborted');
       return 'original-rejected';
-    });
+    }));
 
-    const stealResult = await navigator.locks.request('steal-target', { steal: true }, async (stolenLock) => {
-      assert.strictEqual(stolenLock.name, 'steal-target');
-      assert.strictEqual(stolenLock.mode, 'exclusive');
-      return 'steal-completed';
-    });
+    const stealResult = await navigator.locks.request(
+      'steal-target', { steal: true },
+      common.mustCall(async (stolenLock) => {
+        assert.strictEqual(stolenLock.name, 'steal-target');
+        assert.strictEqual(stolenLock.mode, 'exclusive');
+        return 'steal-completed';
+      }));
 
     assert.strictEqual(stealResult, 'steal-completed');
 
@@ -92,7 +94,7 @@ describe('Web Locks with worker threads', () => {
   });
 
   it('should handle ifAvailable option', async () => {
-    await navigator.locks.request('ifavailable-test', async () => {
+    await navigator.locks.request('ifavailable-test', common.mustCall(async () => {
       const result = await navigator.locks.request('ifavailable-test', { ifAvailable: true }, (lock) => {
         return lock; // should be null
       });
@@ -105,7 +107,7 @@ describe('Web Locks with worker threads', () => {
                                                             });
 
       assert.strictEqual(availableResult, true);
-    });
+    }));
   });
 
   it('should handle AbortSignal', async () => {
@@ -179,18 +181,18 @@ describe('Web Locks with worker threads', () => {
     const als = new AsyncLocalStorage();
     const store = { id: 'lock' };
 
-    als.run(store, () => {
+    als.run(store, common.mustCall(() => {
       navigator.locks
-        .request('als-context-test', async () => {
+        .request('als-context-test', common.mustCall(async () => {
           assert.strictEqual(als.getStore(), store);
-        })
+        }))
         .then(common.mustCall());
-    });
+    }));
   });
 
   it('should clean up when worker is terminated with a pending lock', async () => {
     // Acquire the lock in the main thread so that the worker's request will be pending
-    await navigator.locks.request('cleanup-test', async () => {
+    await navigator.locks.request('cleanup-test', common.mustCall(async () => {
       // Launch a worker that requests the same lock
       const worker = new Worker(`
         const { parentPort } = require('worker_threads');
@@ -212,11 +214,11 @@ describe('Web Locks with worker threads', () => {
 
       await worker.terminate();
 
-    });
+    }));
 
     // Request the lock again to make sure cleanup succeeded
-    await navigator.locks.request('cleanup-test', async (lock) => {
+    await navigator.locks.request('cleanup-test', common.mustCall(async (lock) => {
       assert.strictEqual(lock.name, 'cleanup-test');
-    });
+    }));
   });
 });

test/parallel/test-webcrypto-cryptokey-workers.js

@@ -30,10 +30,10 @@ async function doSig(key) {
 }
 
 if (process.env.HAS_STARTED_WORKER) {
-  return parentPort.once('message', (key) => {
+  return parentPort.once('message', common.mustCall((key) => {
     assert.strictEqual(key.algorithm.name, 'HMAC');
     doSig(key).then(common.mustCall());
-  });
+  }));
 }
 
 // Don't use isMainThread to allow running this test inside a worker.