@khanacademy/wonder-blocks-testing 7.0.5 → 7.1.2

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # @khanacademy/wonder-blocks-testing
 
+## 7.1.2
+
+### Patch Changes
+
+-   Updated dependencies [eb59ce34]
+    -   @khanacademy/wonder-blocks-data@9.1.1
+
+## 7.1.1
+
+### Patch Changes
+
+-   Updated dependencies [944c3071]
+    -   @khanacademy/wonder-blocks-data@9.1.0
+
+## 7.1.0
+
+### Minor Changes
+
+-   17301778: Add `toPromise` method to mock responses
+
+### Patch Changes
+
+-   d5a13e6d: `RespondWith` API now supports a signal for controlling the settlement of the promise. Introduces `SettleController` to support this new feature.
+
 ## 7.0.5
 
 ### Patch Changes

package/dist/es/index.js

@@ -1,5 +1,7 @@
 import * as React from 'react';
 import { action } from '@storybook/addon-actions';
+import _classPrivateFieldLooseBase from '@babel/runtime/helpers/classPrivateFieldLooseBase';
+import _classPrivateFieldLooseKey from '@babel/runtime/helpers/classPrivateFieldLooseKey';
 import { InterceptRequests } from '@khanacademy/wonder-blocks-data';
 import { StaticRouter, MemoryRouter, Switch, Route } from 'react-router-dom';
 import _extends from '@babel/runtime/helpers/extends';
@@ -59,66 +61,6 @@ const fetchRequestMatchesMock = (mock, input, init) => {
   }
 };
 
-const ResponseImpl = typeof Response === "undefined" ? require("node-fetch").Response : Response;
-
-const textResponse = (text, statusCode = 200) => ({
-  type: "text",
-  text,
-  statusCode
-});
-
-const rejectResponse = error => ({
-  type: "reject",
-  error
-});
-
-const RespondWith = Object.freeze({
-  text: (text, statusCode = 200) => textResponse(text, statusCode),
-  json: json => textResponse(() => JSON.stringify(json)),
-  graphQLData: data => textResponse(() => JSON.stringify({
-    data
-  })),
-  unparseableBody: () => textResponse("INVALID JSON"),
-  abortedRequest: () => rejectResponse(() => {
-    const abortError = new Error("Mock request aborted");
-    abortError.name = "AbortError";
-    return abortError;
-  }),
-  reject: error => rejectResponse(error),
-  errorStatusCode: statusCode => {
-    if (statusCode < 300) {
-      throw new Error(`${statusCode} is not a valid error status code`);
-    }
-
-    return textResponse("{}", statusCode);
-  },
-  nonGraphQLBody: () => textResponse(() => JSON.stringify({
-    valid: "json",
-    that: "is not a valid graphql response"
-  })),
-  graphQLErrors: errorMessages => textResponse(() => JSON.stringify({
-    errors: errorMessages.map(e => ({
-      message: e
-    }))
-  }))
-});
-const makeMockResponse = response => {
-  switch (response.type) {
-    case "text":
-      const text = typeof response.text === "function" ? response.text() : response.text;
-      return Promise.resolve(new ResponseImpl(text, {
-        status: response.statusCode
-      }));
-
-    case "reject":
-      const error = response.error instanceof Error ? response.error : response.error();
-      return Promise.reject(error);
-
-    default:
-      throw new Error(`Unknown response type: ${response.type}`);
-  }
-};
-
 const mockRequester = (operationMatcher, operationToString) => {
   const mocks = [];
 
@@ -139,7 +81,7 @@ const mockRequester = (operationMatcher, operationToString) => {
   };
 
   const addMockedOperation = (operation, response, onceOnly) => {
-    const mockResponse = () => makeMockResponse(response);
+    const mockResponse = () => response.toPromise();
 
     mocks.push({
       operation,
@@ -217,6 +159,162 @@ const mockGqlFetch = () => mockRequester(gqlRequestMatchesMock, (operation, vari
     Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
     Context: ${JSON.stringify(context, null, 2)}`);
 
+var _settled = _classPrivateFieldLooseKey("settled");
+
+class SettleSignal extends EventTarget {
+  constructor(setSettleFn = null) {
+    super();
+    Object.defineProperty(this, _settled, {
+      writable: true,
+      value: false
+    });
+    setSettleFn == null ? void 0 : setSettleFn(() => {
+      if (_classPrivateFieldLooseBase(this, _settled)[_settled]) {
+        throw new Error("SettleSignal already settled");
+      }
+
+      _classPrivateFieldLooseBase(this, _settled)[_settled] = true;
+      this.dispatchEvent(new Event("settled"));
+    });
+  }
+
+  static settle() {
+    const signal = new SettleSignal();
+    _classPrivateFieldLooseBase(signal, _settled)[_settled] = true;
+    return signal;
+  }
+
+  get settled() {
+    return _classPrivateFieldLooseBase(this, _settled)[_settled];
+  }
+
+}
+
+const ResponseImpl = typeof Response === "undefined" ? require("node-fetch").Response : Response;
+
+const textResponse = (text, statusCode, signal) => ({
+  toPromise: () => makeMockResponse({
+    type: "text",
+    text,
+    statusCode,
+    signal
+  })
+});
+
+const rejectResponse = (error, signal) => ({
+  toPromise: () => makeMockResponse({
+    type: "reject",
+    error,
+    signal
+  })
+});
+
+const RespondWith = Object.freeze({
+  text: (text, statusCode = 200, signal = null) => textResponse(text, statusCode, signal),
+  json: (json, signal = null) => textResponse(() => JSON.stringify(json), 200, signal),
+  graphQLData: (data, signal = null) => textResponse(() => JSON.stringify({
+    data
+  }), 200, signal),
+  unparseableBody: (signal = null) => textResponse("INVALID JSON", 200, signal),
+  abortedRequest: (signal = null) => rejectResponse(() => {
+    const abortError = new Error("Mock request aborted");
+    abortError.name = "AbortError";
+    return abortError;
+  }, signal),
+  reject: (error, signal = null) => rejectResponse(error, signal),
+  errorStatusCode: (statusCode, signal = null) => {
+    if (statusCode < 300) {
+      throw new Error(`${statusCode} is not a valid error status code`);
+    }
+
+    return textResponse("{}", statusCode, signal);
+  },
+  nonGraphQLBody: (signal = null) => textResponse(() => JSON.stringify({
+    valid: "json",
+    that: "is not a valid graphql response"
+  }), 200, signal),
+  graphQLErrors: (errorMessages, signal = null) => textResponse(() => JSON.stringify({
+    errors: errorMessages.map(e => ({
+      message: e
+    }))
+  }), 200, signal)
+});
+
+const callOnSettled = (signal, fn) => {
+  if (signal == null || signal.settled) {
+    fn();
+    return;
+  }
+
+  const onSettled = () => {
+    signal.removeEventListener("settled", onSettled);
+    fn();
+  };
+
+  signal.addEventListener("settled", onSettled);
+};
+
+const makeMockResponse = response => {
+  const {
+    signal
+  } = response;
+
+  switch (response.type) {
+    case "text":
+      return new Promise((resolve, reject) => {
+        callOnSettled(signal, () => {
+          const text = typeof response.text === "function" ? response.text() : response.text;
+          resolve(new ResponseImpl(text, {
+            status: response.statusCode
+          }));
+        });
+      });
+
+    case "reject":
+      return new Promise((resolve, reject) => {
+        callOnSettled(signal, () => reject(response.error instanceof Error ? response.error : response.error()));
+      });
+
+    default:
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(`Unknown response type: ${response.type}`);
+      }
+
+      return makeMockResponse({
+        type: "reject",
+        error: new Error("Unknown response type"),
+        signal
+      });
+  }
+};
+
+var _settleFn = _classPrivateFieldLooseKey("settleFn");
+
+var _signal = _classPrivateFieldLooseKey("signal");
+
+class SettleController {
+  constructor() {
+    Object.defineProperty(this, _settleFn, {
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, _signal, {
+      writable: true,
+      value: void 0
+    });
+    _classPrivateFieldLooseBase(this, _signal)[_signal] = new SettleSignal(settleFn => _classPrivateFieldLooseBase(this, _settleFn)[_settleFn] = settleFn);
+  }
+
+  get signal() {
+    return _classPrivateFieldLooseBase(this, _signal)[_signal];
+  }
+
+  settle() {
+    _classPrivateFieldLooseBase(this, _settleFn)[_settleFn]();
+  }
+
+}
+
 const defaultConfig$3 = null;
 
 const normalizeConfig = config => {
@@ -401,4 +499,4 @@ const hookHarness = makeHookHarness(DefaultAdapters, DefaultConfigs);
 
 const testHarness = makeTestHarness(DefaultAdapters, DefaultConfigs);
 
-export { RespondWith, fixtures, adapters as harnessAdapters, hookHarness, makeHookHarness, makeTestHarness, mockFetch, mockGqlFetch, testHarness };
+export { RespondWith, SettleController, fixtures, adapters as harnessAdapters, hookHarness, makeHookHarness, makeTestHarness, mockFetch, mockGqlFetch, testHarness };