feat: Wait for all handled requests to resolve via .flush()

packages/@pollyjs/adapter/src/index.js

@@ -87,17 +87,27 @@ export default class Adapter {
     }
   }
 
-  handleRequest() {
-    return this[REQUEST_HANDLER](...arguments);
+  async handleRequest(request) {
+    const pollyRequest = this.polly.registerRequest(request);
+
+    await pollyRequest.setup();
+
+    try {
+      const response = await this[REQUEST_HANDLER](pollyRequest);
+
+      pollyRequest.promise.resolve(response);
+
+      return response;
+    } catch (error) {
+      pollyRequest.promise.reject(error);
+      throw error;
+    }
   }
 
-  async [REQUEST_HANDLER](request) {
+  async [REQUEST_HANDLER](pollyRequest) {
     const { mode } = this.polly;
-    const pollyRequest = this.polly.registerRequest(request);
     let interceptor;
 
-    await pollyRequest.setup();
-
     if (pollyRequest.shouldIntercept) {
       interceptor = new Interceptor();
       const response = await this.intercept(pollyRequest, interceptor);

packages/@pollyjs/core/src/-private/request.js

@@ -6,7 +6,7 @@ import NormalizeRequest from '../utils/normalize-request';
 import removeHostFromUrl from '../utils/remove-host-from-url';
 import serializeRequestBody from '../utils/serialize-request-body';
 import isAbsoluteUrl from 'is-absolute-url';
-import { assert, timestamp } from '@pollyjs/utils';
+import { assert, timestamp, DeferredPromise } from '@pollyjs/utils';
 import HTTPBase from './http-base';
 
 const { keys, freeze } = Object;
@@ -29,6 +29,7 @@ export default class PollyRequest extends HTTPBase {
     this.recordingName = polly.recordingName;
     this.recordingId = polly.recordingId;
     this.requestArguments = freeze(request.requestArguments || []);
+    this.promise = DeferredPromise();
     this[POLLY] = polly;
 
     /*

packages/@pollyjs/core/src/polly.js

@@ -234,6 +234,14 @@ export default class Polly {
     }
   }
 
+  async flush() {
+    const NOOP = () => {};
+
+    await Promise.all(
+      this._requests.map(r => Promise.resolve(r.promise).then(NOOP, NOOP))
+    );
+  }
+
   /**
    * @param {String|Function} nameOrFactory
    * @public

packages/@pollyjs/utils/src/index.js

@@ -6,6 +6,7 @@ export { default as assert } from './utils/assert';
 export { default as timeout } from './utils/timeout';
 export { default as timestamp } from './utils/timestamp';
 export { default as buildUrl } from './utils/build-url';
+export { default as DeferredPromise } from './utils/deferred-promise';
 
 export { default as XHR } from './utils/xhr';
 export { default as Fetch } from './utils/fetch';

packages/@pollyjs/utils/src/utils/deferred-promise.js

@@ -0,0 +1,17 @@
+/**
+ * Create a deferred promise with `resolve` and `reject` methods.
+ *
+ * @returns {Promise}
+ */
+export default function DeferredPromise() {
+  let resolve, reject;
+  const promise = new Promise((_resolve, _reject) => {
+    resolve = _resolve;
+    reject = _reject;
+  });
+
+  promise.resolve = resolve;
+  promise.reject = reject;
+
+  return promise;
+}

packages/@pollyjs/utils/tests/unit/utils/deferred-promise-test.js

@@ -0,0 +1,23 @@
+import DeferredPromise from '../../../src/utils/deferred-promise';
+
+describe('Unit | Utils | DeferredPromise', function() {
+  it('should exist', function() {
+    expect(DeferredPromise).to.be.a('function');
+    expect(DeferredPromise().resolve).to.be.a('function');
+    expect(DeferredPromise().reject).to.be.a('function');
+  });
+
+  it('should resolve when calling .resolve()', async function() {
+    const promise = DeferredPromise();
+
+    promise.resolve(42);
+    expect(await promise).to.equal(42);
+  });
+
+  it('should reject when calling .reject()', async function() {
+    const promise = DeferredPromise();
+
+    promise.reject(new Error('42'));
+    expect(async () => await promise).to.throw(Error, /42/);
+  });
+});