test: enforce better never-settling-promise detection

Tests should be explicit regarding whether a promise is expected to
settle, and the test should fail when the behavior does not meet
expectations.

Author: aduh95

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

@@ -1,12 +1,8 @@
 'use strict';
 
 const common = require('../../common');
-const assert = require('assert');
 const { testResolveAsync } = require(`./build/${common.buildType}/binding`);
 
 // Checks that resolving promises from C++ works.
 
-let called = false;
-testResolveAsync().then(() => { called = true; });
-
-process.on('beforeExit', common.mustCall(() => { assert(called); }));
+testResolveAsync().then(common.mustCall());

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

@@ -106,6 +106,7 @@ function fireErr5() {
   const makeOrphan = vm.compileFunction(`(${String(() => {
     async function main() {
       await null;
+      // eslint-disable-next-line node-core/must-call-assert
       Promise.resolve().then(() => {
         throw new Error('err5');
       });

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

@@ -11,11 +11,11 @@ async function main() {
       assert.strictEqual(asyncLocalStorage.getStore().get('a'), 1);
       throw err;
     });
-  await assert.rejects(new Promise((resolve, reject) => {
+  await assert.rejects(new Promise((resolve) => {
     asyncLocalStorage.run(new Map(), () => {
       const store = asyncLocalStorage.getStore();
       store.set('a', 1);
-      next().then(resolve, reject);
+      resolve(next());
     });
   }), err);
   assert.strictEqual(asyncLocalStorage.getStore(), undefined);

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

@@ -48,6 +48,6 @@ store.run(data, common.mustCall(() => {
 // Returning a thenable in a then handler
 store.run(data, common.mustCall(() => {
   assert.strictEqual(store.getStore(), data);
-  Promise.resolve().then(() => thenable());
+  Promise.resolve().then(() => thenable()).then(common.mustCall());
   assert.strictEqual(store.getStore(), data);
 }));

test/async-hooks/test-destroy-not-blocked.js

@@ -64,9 +64,9 @@ function testPromise() {
   assert.strictEqual(activeId, res.asyncId());
   res.emitDestroy();
   // Promise has higher prio than emit destroy
-  Promise.resolve().then(common.mustCall(() =>
-    assert.strictEqual(activeId, res.asyncId())),
-  );
+  Promise.resolve().then(common.mustCall(() => {
+    assert.strictEqual(activeId, res.asyncId());
+  }));
 }
 
 async function testAwait() {

test/async-hooks/test-promise.chain-promise-before-init-hooks.js

@@ -17,7 +17,7 @@ const p = new Promise(common.mustCall(function executor(resolve) {
 p.then(function afterResolution(val) {
   assert.strictEqual(val, 5);
   return val;
-});
+}).then(common.mustCall());
 
 // Init hooks after chained promise is created
 const hooks = initHooks();
@@ -34,7 +34,7 @@ process.on('exit', function onexit() {
   const as = hooks.activitiesOfTypes('PROMISE');
   const unknown = hooks.activitiesOfTypes('Unknown');
   assert.strictEqual(as.length, 0);
-  assert.strictEqual(unknown.length, 1);
+  assert.strictEqual(unknown.length, 2);
 
   const a0 = unknown[0];
   assert.strictEqual(a0.type, 'Unknown');

test/async-hooks/test-promise.js

@@ -16,14 +16,14 @@ const hooks = initHooks();
 hooks.enable();
 
 const p = new Promise(common.mustCall(executor));
-p.then(function afterResolution(val) {
+p.then(common.mustCall(function afterResolution(val) {
   assert.strictEqual(val, 5);
   const as = hooks.activitiesOfTypes('PROMISE');
   assert.strictEqual(as.length, 2);
   checkInvocations(as[0], { init: 1 }, 'after resolution parent promise');
   checkInvocations(as[1], { init: 1, before: 1 },
                    'after resolution child promise');
-});
+}));
 
 function executor(resolve) {
   const as = hooks.activitiesOfTypes('PROMISE');

test/async-hooks/test-promise.promise-before-init-hooks.js

@@ -16,18 +16,18 @@ hooks.enable();
 p.then(function afterResolution(val) {
   assert.strictEqual(val, 5);
   const as = hooks.activitiesOfTypes('PROMISE');
-  assert.strictEqual(as.length, 1);
+  assert.strictEqual(as.length, 2);
   checkInvocations(as[0], { init: 1, before: 1 },
                    'after resolution child promise');
   return val;
-});
+}).then(common.mustCall());
 
 process.on('exit', function onexit() {
   hooks.disable();
   hooks.sanityCheck('PROMISE');
 
   const as = hooks.activitiesOfTypes('PROMISE');
-  assert.strictEqual(as.length, 1);
+  assert.strictEqual(as.length, 2);
 
   const a0 = as[0];
   assert.strictEqual(a0.type, 'PROMISE');

test/client-proxy/test-http-proxy-request-max-sockets.mjs

@@ -20,7 +20,7 @@ const server = http.createServer(common.mustCall((req, res) => {
       console.log('Responding to /first');
       res.writeHead(200, { 'Content-Type': 'text/plain' });
       res.end('Response for /first');
-    });
+    }).then(common.mustCall());
   } else if (req.url === '/second') {
     // Respond immediately for the second request
     res.writeHead(200, { 'Content-Type': 'text/plain' });

test/client-proxy/test-https-proxy-request-max-sockets.mjs

@@ -31,7 +31,7 @@ const server = https.createServer({
       console.log('Responding to /first');
       res.writeHead(200, { 'Content-Type': 'text/plain' });
       res.end('Response for /first');
-    });
+    }).then(common.mustCall());
   } else if (req.url === '/second') {
     // Respond immediately for the second request
     res.writeHead(200, { 'Content-Type': 'text/plain' });