@khanacademy/wonder-blocks-testing 7.1.6 → 7.1.8

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @khanacademy/wonder-blocks-testing
 
+## 7.1.8
+
+### Patch Changes
+
+-   @khanacademy/wonder-blocks-data@10.0.4
+
+## 7.1.7
+
+### Patch Changes
+
+-   @khanacademy/wonder-blocks-data@10.0.3
+
 ## 7.1.6
 
 ### Patch Changes

package/dist/index.js

@@ -0,0 +1,540 @@
+'use strict';
+
+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;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n["default"] = e;
+    return Object.freeze(n);
+}
+
+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();
+  let storyNumber = 1;
+  const getPropsOptions = {
+    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;
+};
+
+const getHref = input => {
+  if (typeof input === "string") {
+    return input;
+  } else if (typeof input.url === "string") {
+    return input.url;
+  } else if (typeof input.href === "string") {
+    return input.href;
+  } else {
+    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) {
+    return mock.test(href);
+  } else {
+    throw new Error(`Unsupported mock operation: ${JSON.stringify(mock)}`);
+  }
+};
+
+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();
+      }
+    }
+
+    return Promise.reject(new Error(`No matching mock response found for request:
+    ${operationToString.apply(void 0, args)}`));
+  };
+
+  const addMockedOperation = (operation, response, onceOnly) => {
+    const mockResponse = () => response.toPromise();
+
+    mocks.push({
+      operation,
+      response: mockResponse,
+      onceOnly,
+      used: false
+    });
+    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)}`);
+
+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];
+  }
+
+}
+
+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__default["default"]("settleFn");
+
+var _signal = _classPrivateFieldLooseKey__default["default"]("signal");
+
+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);
+  }
+
+  get signal() {
+    return _classPrivateFieldLooseBase__default["default"](this, _signal)[_signal];
+  }
+
+  settle() {
+    _classPrivateFieldLooseBase__default["default"](this, _settleFn)[_settleFn]();
+  }
+
+}
+
+const defaultConfig$3 = null;
+
+const normalizeConfig = config => {
+  if (typeof config === "string") {
+    return {
+      classes: [config],
+      style: {}
+    };
+  }
+
+  if (Array.isArray(config)) {
+    return {
+      classes: config,
+      style: {}
+    };
+  }
+
+  if (typeof config === "object") {
+    if (config.classes != null && config.style != null) {
+      return config;
+    }
+
+    return {
+      classes: [],
+      style: config
+    };
+  }
+
+  throw new Error(`Invalid config: ${config}`);
+};
+
+const adapter$3 = (children, config) => {
+  const {
+    classes,
+    style
+  } = normalizeConfig(config);
+  return React__namespace.createElement("div", {
+    "data-test-id": "css-adapter-container",
+    className: classes.join(" "),
+    style: style
+  }, children);
+};
+
+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);
+};
+
+const defaultConfig$1 = null;
+const adapter$1 = (children, config) => React__namespace.createElement(React__namespace.Fragment, null, React__namespace.createElement("div", {
+  id: config,
+  "data-test-id": config
+}), children);
+
+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
+  }, children), React__namespace.createElement(reactRouterDom.Route, {
+    path: "*",
+    render: () => {
+      throw new Error("The configured path must match the configured location or your harnessed component will not render.");
+    }
+  }));
+};
+
+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);
+};
+
+const DefaultAdapters = {
+  css: adapter$3,
+  data: adapter$2,
+  portal: adapter$1,
+  router: adapter
+};
+const DefaultConfigs = {
+  css: defaultConfig$3,
+  data: defaultConfig$2,
+  portal: defaultConfig$1,
+  router: defaultConfig
+};
+
+var adapters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    DefaultAdapters: DefaultAdapters,
+    DefaultConfigs: DefaultConfigs
+});
+
+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, {
+      ref: ref
+    }))));
+    harnessedComponent.displayName = `testHarness(${Component.displayName || Component.name || "Component"})`;
+    return harnessedComponent;
+  };
+};
+
+const HookHarness = ({
+  children
+}) => children;
+
+const makeHookHarness = (adapters, defaultConfigs) => {
+  const testHarness = makeTestHarness(adapters, defaultConfigs);
+  return configs => testHarness(HookHarness, configs);
+};
+
+const hookHarness = makeHookHarness(DefaultAdapters, DefaultConfigs);
+
+const testHarness = makeTestHarness(DefaultAdapters, DefaultConfigs);
+
+exports.RespondWith = RespondWith;
+exports.SettleController = SettleController;
+exports.fixtures = fixtures;
+exports.harnessAdapters = adapters;
+exports.hookHarness = hookHarness;
+exports.makeHookHarness = makeHookHarness;
+exports.makeTestHarness = makeTestHarness;
+exports.mockFetch = mockFetch;
+exports.mockGqlFetch = mockGqlFetch;
+exports.testHarness = testHarness;

package/dist/index.js.flow

@@ -0,0 +1,2 @@
+// @flow
+export * from "../src/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@khanacademy/wonder-blocks-testing",
-    "version": "7.1.6",
+    "version": "7.1.8",
     "design": "v1",
     "publishConfig": {
         "access": "public"
@@ -14,7 +14,7 @@
     },
     "dependencies": {
         "@babel/runtime": "^7.18.6",
-        "@khanacademy/wonder-blocks-data": "^10.0.2"
+        "@khanacademy/wonder-blocks-data": "^10.0.4"
     },
     "peerDependencies": {
         "@khanacademy/wonder-stuff-core": "^0.1.2",
@@ -26,7 +26,7 @@
         "react-router-dom": "5.3.0"
     },
     "devDependencies": {
-        "wb-dev-build-settings": "^0.5.0"
+        "wb-dev-build-settings": "^0.7.0"
     },
     "author": "",
     "license": "MIT"