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.

PR-URL: https://github.com/nodejs/node/pull/19650
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>

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(
+common.crashOnUnhandledRejection();
-  () => assert.fail(),
-  common.expectsError({
-    code: 'ERR_ASSERTION',
-    type: assert.AssertionError,
-    message: 'Failed'
-  })
-);
 
-assert.doesNotReject(() => {});
+(async () => {
-
+  await assert.rejects(
-{
+    () => assert.fail(),
-  const promise = assert.rejects(async () => {
+    common.expectsError({
-    await wait(1);
+      code: 'ERR_ASSERTION',
-    assert.fail();
+      type: assert.AssertionError,
-  }, common.expectsError({
+      message: 'Failed'
-    code: 'ERR_ASSERTION',
+    })
-    type: assert.AssertionError,
-    message: 'Failed'
-  }));
-  assert.doesNotReject(() => promise);
-}
-
-{
-  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;
-                 }
   );
-}
 
-{
+  await assert.doesNotReject(() => {});
-  const promise = assert.rejects(() => {});
+
-  assert.rejects(() => promise,
+  {
-                 (err) => {
+    const promise = assert.doesNotReject(async () => {
-                   assert(err instanceof assert.AssertionError,
+      await wait(1);
-                          `${err.name} is not instance of AssertionError`);
+      throw new Error();
-                   assert.strictEqual(err.code, 'ERR_ASSERTION');
+    });
-                   assert(/^Missing expected rejection\.$/.test(err.message));
+    await assert.rejects(
-                   assert.strictEqual(err.operator, 'rejects');
+      () => promise,
-                   assert.ok(!err.stack.includes('at Function.rejects'));
+      (err) => {
-                   return true;
+        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(() => {});
+    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());