polish: add expectPromise.toReject helper (#4694)

and implement toRejectWith in terms of toReject

extracted from #4670

Author: yaacovCR

src/__testUtils__/__tests__/expectPromise-test.ts

@@ -16,6 +16,24 @@ describe('expectPromise', () => {
     expect(await expectPromise(promise).toResolve()).to.equal(testValue);
   });
 
+  it('toReject throws if the promise does not reject', async () => {
+    try {
+      await expectPromise(Promise.resolve({})).toReject(); /* c8 ignore start */
+    } /* c8 ignore stop */ catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      expect(errorMessage).to.equal(
+        "Promise should have rejected, but resolved as '{}'",
+      );
+    }
+  });
+
+  it('toReject returns the rejected reason', async () => {
+    const error = new Error('foo');
+    expect(await expectPromise(Promise.reject(error)).toReject()).to.equal(
+      error,
+    );
+  });
+
   it('toRejectWith throws if the promise does not reject', async () => {
     try {
       await expectPromise(Promise.resolve({})).toRejectWith(

src/__testUtils__/expectPromise.ts

@@ -5,6 +5,7 @@ import { isPromise } from '../jsutils/isPromise.js';
 
 interface PromiseExpectation {
   toResolve: () => Promise<unknown>;
+  toReject: () => Promise<unknown>;
   toRejectWith: (message: string) => Promise<Error>;
 }
 
@@ -18,6 +19,24 @@ export function expectPromise(maybePromise: unknown): PromiseExpectation {
     toResolve(): Promise<unknown> {
       return maybePromise;
     },
+    async toReject(): Promise<unknown> {
+      let caughtError: unknown;
+      let resolved;
+      let rejected = false;
+      try {
+        resolved = await maybePromise;
+      } catch (error) {
+        rejected = true;
+        caughtError = error;
+      }
+
+      assert(
+        rejected,
+        `Promise should have rejected, but resolved as '${inspect(resolved)}'`,
+      );
+
+      return caughtError;
+    },
     async toRejectWith(message: string): Promise<Error> {
       let caughtError: unknown;
       let resolved;

src/execution/__tests__/subscribe-test.ts

@@ -1051,13 +1051,9 @@ describe('Subscription Publish Phase', () => {
     payload = subscription.next();
 
     // Throw error
-    let caughtError;
-    try {
-      /* c8 ignore next 2 */
-      await subscription.throw('ouch');
-    } catch (e) {
-      caughtError = e;
-    }
+    const caughtError = await expectPromise(
+      subscription.throw('ouch'),
+    ).toReject();
     expect(caughtError).to.equal('ouch');
 
     expect(await payload).to.deep.equal({