test: ensure failed assertions cause build to fail

This updates the test in `test/parallel/test-assert-async.js` to add an
assertion that the Promises used in the test end up fulfilled.
Previously, if an assertion failure occurred, the Promises would have
rejected and a warning would have been logged, but the test would still
have exit code 0.

Backport-PR-URL: #24019
PR-URL: #19650
Reviewed-By: James M Snell <[email protected]>
Reviewed-By: Ruben Bridgewater <[email protected]>

Author: not-an-aardvark

test/parallel/test-assert-async.js

@@ -9,58 +9,52 @@ const wait = promisify(setTimeout);
 // Test assert.rejects() and assert.doesNotReject() by checking their
 // expected output and by verifying that they do not work sync
 
-assert.rejects(
-  () => assert.fail(),
-  common.expectsError({
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'Failed'
-  })
-);
+common.crashOnUnhandledRejection();
 
-assert.doesNotReject(() => {});
+(async () => {
+  await assert.rejects(
+    () => assert.fail(),
+    common.expectsError({
+      code: 'ERR_ASSERTION',
+      type: assert.AssertionError,
+      message: 'Failed'
+    })
+  );
 
-{
-  const promise = assert.rejects(async () => {
-    await wait(1);
-    assert.fail();
-  }, common.expectsError({
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'Failed'
-  }));
-  assert.doesNotReject(() => promise);
-}
+  await assert.doesNotReject(() => {});
 
-{
-  const promise = assert.doesNotReject(async () => {
-    await wait(1);
-    throw new Error();
-  });
-  assert.rejects(() => promise,
-                 (err) => {
-                   assert(err instanceof assert.AssertionError,
-                          `${err.name} is not instance of AssertionError`);
-                   assert.strictEqual(err.code, 'ERR_ASSERTION');
-                   assert(/^Got unwanted rejection\.\n$/.test(err.message));
-                   assert.strictEqual(err.operator, 'doesNotReject');
-                   assert.ok(!err.stack.includes('at Function.doesNotReject'));
-                   return true;
-                 }
-  );
-}
+  {
+    const promise = assert.doesNotReject(async () => {
+      await wait(1);
+      throw new Error();
+    });
+    await assert.rejects(
+      () => promise,
+      (err) => {
+        assert(err instanceof assert.AssertionError,
+               `${err.name} is not instance of AssertionError`);
+        assert.strictEqual(err.code, 'ERR_ASSERTION');
+        assert(/^Got unwanted rejection\.\n$/.test(err.message));
+        assert.strictEqual(err.operator, 'doesNotReject');
+        assert.ok(!err.stack.includes('at Function.doesNotReject'));
+        return true;
+      }
+    );
+  }
 
-{
-  const promise = assert.rejects(() => {});
-  assert.rejects(() => promise,
-                 (err) => {
-                   assert(err instanceof assert.AssertionError,
-                          `${err.name} is not instance of AssertionError`);
-                   assert.strictEqual(err.code, 'ERR_ASSERTION');
-                   assert(/^Missing expected rejection\.$/.test(err.message));
-                   assert.strictEqual(err.operator, 'rejects');
-                   assert.ok(!err.stack.includes('at Function.rejects'));
-                   return true;
-                 }
-  );
-}
+  {
+    const promise = assert.rejects(() => {});
+    await assert.rejects(
+      () => promise,
+      (err) => {
+        assert(err instanceof assert.AssertionError,
+               `${err.name} is not instance of AssertionError`);
+        assert.strictEqual(err.code, 'ERR_ASSERTION');
+        assert(/^Missing expected rejection\.$/.test(err.message));
+        assert.strictEqual(err.operator, 'rejects');
+        assert.ok(!err.stack.includes('at Function.rejects'));
+        return true;
+      }
+    );
+  }
+})().then(common.mustCall());