fixup! test: ensure assertions are reachable in more folders

Author: aduh95

test/parallel/test-eslint-must-call-assert.js

@@ -70,12 +70,23 @@ tester.run('must-call-assert', rule, {
     import assert from 'node:assert';
 
     describe("whatever", () => {
-      it("should not be reported", async () => {
+      it("should not be reported", async (t) => {
         assert.strictEqual(2+2, 5);
+        await t.test("name", () => {
+          assert.ok(global.test);
+        });
       });
     });
     `,
     `
+    process.on("message", common.mustCall(() => {
+      Promise.all([].map(async (val) => {
+        val = await asyncTask(val);
+        assert.strictEqual(val, 3);
+      })).then(common.mustCall());
+    }));
+    `,
+    `
     spawnSyncAndAssert(
       outputFile,
       {

test/sea/test-single-executable-application-inspect.js

@@ -64,7 +64,7 @@ seaProcess.stdout.on('data', (data) => {
   console.log(`[SEA][STDOUT] ${data}`);
 });
 
-seaProcess.stderr.on('data', common.mustCall((data) => {
+seaProcess.stderr.on('data', common.mustCallAtLeast((data) => {
   console.log(`[SEA][STDERR] ${data}`);
   seaStderr += data;
 

tools/eslint-rules/must-call-assert.js

@@ -7,6 +7,13 @@ const message =
 const requireCall = 'CallExpression[callee.name="require"]';
 const assertModuleSpecifier = '/^(node:)?assert(.strict)?$/';
 
+const isPromiseAllCallArg = (node) =>
+  node.parent?.type === 'CallExpression' &&
+  node.parent.callee.type === 'MemberExpression' &&
+  node.parent.callee.object.type === 'Identifier' && node.parent.callee.object.name === 'Promise' &&
+  node.parent.callee.property.type === 'Identifier' && node.parent.callee.property.name === 'all' &&
+  node.parent.arguments.length === 1 && node.parent.arguments[0] === node;
+
 function findEnclosingFunction(node) {
   while (true) {
     node = node.parent;
@@ -20,15 +27,18 @@ function findEnclosingFunction(node) {
       if (
         node.parent.callee.type === 'MemberExpression' &&
         (node.parent.callee.object.type === 'ArrayExpression' || node.parent.callee.object.type === 'Identifier') &&
-        node.parent.callee.property.name === 'forEach'
+        (
+          node.parent.callee.property.name === 'forEach' ||
+          (node.parent.callee.property.name === 'map' && isPromiseAllCallArg(node.parent))
+        )
       ) continue; // `[].forEach()` call
     } else if (node.parent?.type === 'NewExpression') {
       if (node.parent.callee.type === 'Identifier' && node.parent.callee.name === 'Promise') continue;
     } else if (node.parent?.type === 'Property') {
       const ancestor = node.parent.parent?.parent;
       if (ancestor?.type === 'CallExpression' &&
           ancestor.callee.type === 'Identifier' &&
-          ancestor.callee.name === 'spawnSyncAndAssert') {
+          /^spawnSyncAnd(Exit(WithoutError)?|Assert)$/.test(ancestor.callee.name)) {
         continue;
       }
     }
@@ -75,6 +85,7 @@ module.exports = {
                       parent.arguments[0].type === 'Literal' &&
                       parent.arguments[0].value === 'exit'
                     ),
+                  t: (name) => name === 'test', // t.test
                 }[parent.callee.object.name]?.(parent.callee.property.name)
               ) {
                 return;