@khanacademy/wonder-blocks-testing 7.1.9 → 7.1.11

package/dist/index.js

@@ -4,13 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var React = require('react');
 var addonActions = require('@storybook/addon-actions');
-var _classPrivateFieldLooseBase = require('@babel/runtime/helpers/classPrivateFieldLooseBase');
-var _classPrivateFieldLooseKey = require('@babel/runtime/helpers/classPrivateFieldLooseKey');
 var wonderBlocksData = require('@khanacademy/wonder-blocks-data');
 var reactRouterDom = require('react-router-dom');
-var _extends = require('@babel/runtime/helpers/extends');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
@@ -31,9 +26,6 @@ function _interopNamespace(e) {
 }
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
-var _classPrivateFieldLooseBase__default = /*#__PURE__*/_interopDefaultLegacy(_classPrivateFieldLooseBase);
-var _classPrivateFieldLooseKey__default = /*#__PURE__*/_interopDefaultLegacy(_classPrivateFieldLooseKey);
-var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
 
 const fixtures = Component => {
   const templateMap = new WeakMap();
@@ -42,27 +34,20 @@ const fixtures = Component => {
     log: (message, ...args) => addonActions.action(message).apply(void 0, args),
     logHandler: addonActions.action
   };
-
   const makeStory = (description, props, wrapper = null) => {
     const storyName = `${storyNumber++} ${description}`;
-
     const getProps = options => typeof props === "function" ? props(options) : props;
-
     const RealComponent = wrapper || Component;
     let Template = templateMap.get(RealComponent);
-
     if (Template == null) {
       Template = args => React__namespace.createElement(RealComponent, args);
-
       templateMap.set(RealComponent, Template);
     }
-
     const story = Template.bind({});
     story.args = getProps(getPropsOptions);
     story.storyName = storyName;
     return story;
   };
-
   return makeStory;
 };
 
@@ -77,10 +62,8 @@ const getHref = input => {
     throw new Error(`Unsupported input type`);
   }
 };
-
 const fetchRequestMatchesMock = (mock, input, init) => {
   const href = getHref(input);
-
   if (typeof mock === "string") {
     return href === mock;
   } else if (mock instanceof RegExp) {
@@ -92,26 +75,22 @@ const fetchRequestMatchesMock = (mock, input, init) => {
 
 const mockRequester = (operationMatcher, operationToString) => {
   const mocks = [];
-
   const mockFn = (...args) => {
     for (const mock of mocks) {
       if (mock.onceOnly && mock.used) {
         continue;
       }
-
       if (operationMatcher.apply(void 0, [mock.operation].concat(args))) {
         mock.used = true;
         return mock.response();
       }
     }
-
+    const operation = operationToString.apply(void 0, args);
     return Promise.reject(new Error(`No matching mock response found for request:
-    ${operationToString.apply(void 0, args)}`));
+    ${operation}`));
   };
-
   const addMockedOperation = (operation, response, onceOnly) => {
     const mockResponse = () => response.toPromise();
-
     mocks.push({
       operation,
       response: mockResponse,
@@ -120,104 +99,58 @@ const mockRequester = (operationMatcher, operationToString) => {
     });
     return mockFn;
   };
-
   mockFn.mockOperation = (operation, response) => addMockedOperation(operation, response, false);
-
   mockFn.mockOperationOnce = (operation, response) => addMockedOperation(operation, response, true);
-
   return mockFn;
 };
 
 const mockFetch = () => mockRequester(fetchRequestMatchesMock, (input, init) => `Input: ${typeof input === "string" ? input : JSON.stringify(input, null, 2)}
-    Options: ${init == null ? "None" : JSON.stringify(init, null, 2)}`);
+Options: ${init == null ? "None" : JSON.stringify(init, null, 2)}`);
 
 const safeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
-
 const areObjectsEqual = (a, b) => {
   if (a === b) {
     return true;
   }
-
   if (a == null || b == null) {
     return false;
   }
-
   if (typeof a !== "object" || typeof b !== "object") {
     return false;
   }
-
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
-
   if (aKeys.length !== bKeys.length) {
     return false;
   }
-
   for (let i = 0; i < aKeys.length; i++) {
     const key = aKeys[i];
-
     if (!safeHasOwnProperty(b, key) || !areObjectsEqual(a[key], b[key])) {
       return false;
     }
   }
-
   return true;
 };
-
 const gqlRequestMatchesMock = (mock, operation, variables, context) => {
   if (mock.operation.id !== operation.id || mock.operation.type !== operation.type) {
     return false;
   }
-
   if (mock.variables != null) {
     if (!areObjectsEqual(mock.variables, variables)) {
       return false;
     }
   }
-
   if (mock.context != null) {
     if (!areObjectsEqual(mock.context, context)) {
       return false;
     }
   }
-
   return true;
 };
 
 const mockGqlFetch = () => mockRequester(gqlRequestMatchesMock, (operation, variables, context) => `Operation: ${operation.type} ${operation.id}
-    Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
-    Context: ${JSON.stringify(context, null, 2)}`);
-
-var _settled = _classPrivateFieldLooseKey__default["default"]("settled");
-
-class SettleSignal extends EventTarget {
-  constructor(setSettleFn = null) {
-    super();
-    Object.defineProperty(this, _settled, {
-      writable: true,
-      value: false
-    });
-    setSettleFn == null ? void 0 : setSettleFn(() => {
-      if (_classPrivateFieldLooseBase__default["default"](this, _settled)[_settled]) {
-        throw new Error("SettleSignal already settled");
-      }
-
-      _classPrivateFieldLooseBase__default["default"](this, _settled)[_settled] = true;
-      this.dispatchEvent(new Event("settled"));
-    });
-  }
-
-  static settle() {
-    const signal = new SettleSignal();
-    _classPrivateFieldLooseBase__default["default"](signal, _settled)[_settled] = true;
-    return signal;
-  }
-
-  get settled() {
-    return _classPrivateFieldLooseBase__default["default"](this, _settled)[_settled];
-  }
-
-}
+Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
+Context: ${JSON.stringify(context, null, 2)}`);
 
 const ResponseImpl = typeof Response === "undefined" ? require("node-fetch").Response : Response;
 
@@ -229,7 +162,6 @@ const textResponse = (text, statusCode, signal) => ({
     signal
   })
 });
-
 const rejectResponse = (error, signal) => ({
   toPromise: () => makeMockResponse({
     type: "reject",
@@ -237,7 +169,6 @@ const rejectResponse = (error, signal) => ({
     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),
@@ -255,7 +186,6 @@ const RespondWith = Object.freeze({
     if (statusCode < 300) {
       throw new Error(`${statusCode} is not a valid error status code`);
     }
-
     return textResponse("{}", statusCode, signal);
   },
   nonGraphQLBody: (signal = null) => textResponse(() => JSON.stringify({
@@ -268,26 +198,21 @@ const RespondWith = Object.freeze({
     }))
   }), 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) => {
@@ -298,17 +223,14 @@ const makeMockResponse = response => {
           }));
         });
       });
-
     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"),
@@ -317,35 +239,179 @@ const makeMockResponse = response => {
   }
 };
 
-var _settleFn = _classPrivateFieldLooseKey__default["default"]("settleFn");
+function _typeof(obj) {
+  "@babel/helpers - typeof";
 
-var _signal = _classPrivateFieldLooseKey__default["default"]("signal");
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) {
+    return typeof obj;
+  } : function (obj) {
+    return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+  }, _typeof(obj);
+}
 
-class SettleController {
-  constructor() {
-    Object.defineProperty(this, _settleFn, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _signal, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldLooseBase__default["default"](this, _signal)[_signal] = new SettleSignal(settleFn => _classPrivateFieldLooseBase__default["default"](this, _settleFn)[_settleFn] = settleFn);
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
   }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
 
-  get signal() {
-    return _classPrivateFieldLooseBase__default["default"](this, _signal)[_signal];
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
   }
+}
 
-  settle() {
-    _classPrivateFieldLooseBase__default["default"](this, _settleFn)[_settleFn]();
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
   }
+  return _construct.apply(null, arguments);
+}
 
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
 }
 
-const defaultConfig$3 = null;
+let SettleSignal = function (_EventTarget) {
+  _inheritsLoose(SettleSignal, _EventTarget);
+  function SettleSignal(setSettleFn = null) {
+    var _this;
+    _this = _EventTarget.call(this) || this;
+    _this._settled = false;
+    setSettleFn == null ? void 0 : setSettleFn(() => {
+      if (_this._settled) {
+        throw new Error("SettleSignal already settled");
+      }
+      _this._settled = true;
+      _this.dispatchEvent(new Event("settled"));
+    });
+    return _this;
+  }
+  SettleSignal.settle = function settle() {
+    const signal = new SettleSignal();
+    signal._settled = true;
+    return signal;
+  };
+  _createClass(SettleSignal, [{
+    key: "settled",
+    get: function () {
+      return this._settled;
+    }
+  }]);
+  return SettleSignal;
+}(_wrapNativeSuper(EventTarget));
+
+let SettleController = function () {
+  function SettleController() {
+    this._settleFn = void 0;
+    this._signal = void 0;
+    this._signal = new SettleSignal(settleFn => this._settleFn = settleFn);
+  }
+  var _proto = SettleController.prototype;
+  _proto.settle = function settle() {
+    this._settleFn();
+  };
+  _createClass(SettleController, [{
+    key: "signal",
+    get: function () {
+      return this._signal;
+    }
+  }]);
+  return SettleController;
+}();
 
+const defaultConfig$3 = null;
 const normalizeConfig = config => {
   if (typeof config === "string") {
     return {
@@ -353,28 +419,23 @@ const normalizeConfig = config => {
       style: {}
     };
   }
-
   if (Array.isArray(config)) {
     return {
       classes: config,
       style: {}
     };
   }
-
   if (typeof config === "object") {
-    if (config.classes != null && config.style != null) {
+    if ("classes" in config && config.classes != null && "style" in config && config.style != null) {
       return config;
     }
-
     return {
       classes: [],
       style: config
     };
   }
-
   throw new Error(`Invalid config: ${config}`);
 };
-
 const adapter$3 = (children, config) => {
   const {
     classes,
@@ -391,13 +452,11 @@ const defaultConfig$2 = [];
 const adapter$2 = (children, config) => {
   let currentChildren = children;
   const interceptors = Array.isArray(config) ? config : [config];
-
   for (const interceptor of interceptors) {
     currentChildren = React__namespace.createElement(wonderBlocksData.InterceptRequests, {
       interceptor: interceptor
     }, currentChildren);
   }
-
   return React__namespace.createElement(React__namespace.Fragment, null, currentChildren);
 };
 
@@ -410,12 +469,10 @@ const adapter$1 = (children, config) => React__namespace.createElement(React__na
 const defaultConfig = {
   location: "/"
 };
-
 const maybeWithRoute = (children, path) => {
   if (path == null) {
     return children;
   }
-
   return React__namespace.createElement(reactRouterDom.Switch, null, React__namespace.createElement(reactRouterDom.Route, {
     exact: true,
     path: path
@@ -426,46 +483,37 @@ const maybeWithRoute = (children, path) => {
     }
   }));
 };
-
 const adapter = (children, config) => {
   if (typeof config === "string") {
     config = {
       location: config
     };
   }
-
   const wrappedWithRoute = maybeWithRoute(children, config.path);
-
   if (config.forceStatic) {
     return React__namespace.createElement(reactRouterDom.StaticRouter, {
       location: config.location,
       context: {}
     }, wrappedWithRoute);
   }
-
   if (typeof config.location !== "undefined") {
     return React__namespace.createElement(reactRouterDom.MemoryRouter, {
       initialEntries: [config.location]
     }, wrappedWithRoute);
   }
-
   if (typeof config.initialEntries === "undefined") {
     throw new Error("A location or initial history entries must be provided.");
   }
-
   const entries = config.initialEntries.length === 0 ? [defaultConfig.location] : config.initialEntries;
   const routerProps = {
     initialEntries: entries
   };
-
   if (config.initialIndex != null) {
     routerProps.initialIndex = config.initialIndex;
   }
-
   if (config.getUserConfirmation != null) {
     routerProps.getUserConfirmation = config.getUserConfirmation;
   }
-
   return React__namespace.createElement(reactRouterDom.MemoryRouter, routerProps, wrappedWithRoute);
 };
 
@@ -488,26 +536,37 @@ var adapters = /*#__PURE__*/Object.freeze({
     DefaultConfigs: DefaultConfigs
 });
 
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
 const renderAdapters = (adapters, configs, children) => {
   let currentChildren = children;
-
   for (const adapterName of Object.keys(adapters)) {
     const adapter = adapters[adapterName];
     const config = configs[adapterName];
-
     if (config != null) {
       currentChildren = adapter(currentChildren, config);
     }
   }
-
   return currentChildren;
 };
 
 const makeTestHarness = (adapters, defaultConfigs) => {
   return (Component, configs) => {
-    const fullConfig = _extends__default["default"]({}, defaultConfigs, configs);
-
-    const harnessedComponent = React__namespace.forwardRef((props, ref) => renderAdapters(adapters, fullConfig, React__namespace.createElement(Component, _extends__default["default"]({}, props, {
+    const fullConfig = _extends({}, defaultConfigs, configs);
+    const harnessedComponent = React__namespace.forwardRef((props, ref) => renderAdapters(adapters, fullConfig, React__namespace.createElement(Component, _extends({}, props, {
       ref: ref
     }))));
     harnessedComponent.displayName = `testHarness(${Component.displayName || Component.name || "Component"})`;
@@ -518,7 +577,6 @@ const makeTestHarness = (adapters, defaultConfigs) => {
 const HookHarness = ({
   children
 }) => children;
-
 const makeHookHarness = (adapters, defaultConfigs) => {
   const testHarness = makeTestHarness(adapters, defaultConfigs);
   return configs => testHarness(HookHarness, configs);

package/dist/index.js.flow

@@ -1,2 +1,26 @@
-// @flow
-export * from "../src/index.js";
+/**
+ * Flowtype definitions for index
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+declare export { fixtures } from "./fixtures/fixtures";
+export type {
+  FixtureFn,
+  FixtureProps,
+  GetPropsOptions,
+} from "./fixtures/types";
+declare export { mockFetch } from "./fetch/mock-fetch";
+declare export { mockGqlFetch } from "./gql/mock-gql-fetch";
+declare export { RespondWith } from "./respond-with";
+declare export { SettleController } from "./settle-controller";
+export type { MockResponse } from "./respond-with";
+export type { FetchMockFn, FetchMockOperation } from "./fetch/types";
+export type { GqlFetchMockFn, GqlMockOperation } from "./gql/types";
+declare export * from "./harness/types";
+declare export * as harnessAdapters from "./harness/adapters/adapters";
+declare export { makeHookHarness } from "./harness/make-hook-harness";
+declare export { makeTestHarness } from "./harness/make-test-harness";
+declare export { hookHarness } from "./harness/hook-harness";
+declare export { testHarness } from "./harness/test-harness";

package/dist/mock-requester.d.ts

@@ -0,0 +1,5 @@
+import type { OperationMock, OperationMatcher, MockFn } from "./types";
+/**
+ * A generic mock request function for using when mocking fetch or gqlFetch.
+ */
+export declare const mockRequester: <TOperationType, TOperationMock extends OperationMock<TOperationType> = OperationMock<TOperationType>>(operationMatcher: OperationMatcher<any>, operationToString: (operationMock: TOperationMock, ...args: Array<any>) => string) => MockFn<TOperationType>;

package/dist/mock-requester.js.flow

@@ -0,0 +1,22 @@
+/**
+ * Flowtype definitions for mock-requester
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+
+import type { OperationMock, OperationMatcher, MockFn } from "./types";
+
+/**
+ * A generic mock request function for using when mocking fetch or gqlFetch.
+ */
+declare export var mockRequester: <
+  TOperationType,
+  TOperationMock: OperationMock<TOperationType>
+>(
+  operationMatcher: OperationMatcher<any>,
+  operationToString: (
+    operationMock: TOperationMock,
+    ...args: Array<any>
+  ) => string
+) => MockFn<TOperationType>;