@khanacademy/wonder-blocks-testing 4.0.3 → 5.0.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @khanacademy/wonder-blocks-testing
 
+## 5.0.1
+
+### Patch Changes
+
+-   5b1c80d2: Fix test harness types
+
+## 5.0.0
+
+### Major Changes
+
+-   217b2c7b: Add test harness framework
+-   a8d9a825: Adapters for fixture framework now exported as `fixtureAdapters`, adapters for test harness framework now exported as `harnessAdapters`. Various types renamed for disambiguation. `FetchMock` and `GqlMock` export types removed.
+
+## 4.0.4
+
+### Patch Changes
+
+-   Updated dependencies [580141ed]
+    -   @khanacademy/wonder-blocks-data@8.0.2
+
 ## 4.0.3
 
 ### Patch Changes

package/dist/es/index.js

@@ -2,6 +2,8 @@ import _extends from '@babel/runtime/helpers/extends';
 import * as React from 'react';
 import { action } from '@storybook/addon-actions';
 import { clone } from '@khanacademy/wonder-stuff-core';
+import { InterceptRequests } from '@khanacademy/wonder-blocks-data';
+import { StaticRouter, MemoryRouter, Switch, Route } from 'react-router-dom';
 
 class AdapterGroup {
   constructor(closeGroupFn, _options) {
@@ -113,7 +115,7 @@ const getAdapter = (MountingComponent = null) => new Adapter("storybook", ({
   return Object.freeze(exports);
 });
 
-var adapters = /*#__PURE__*/Object.freeze({
+var adapters$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     storybook: getAdapter
 });
@@ -204,6 +206,30 @@ const fixtures = (componentOrOptions, fn) => {
   return group.closeGroup(combinedAdapterOptions);
 };
 
+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 ResponseImpl = typeof Response === "undefined" ? require("node-fetch").Response : Response;
 
 const textResponse = (text, statusCode = 200) => ({
@@ -264,30 +290,6 @@ const makeMockResponse = response => {
   }
 };
 
-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 = [];
 
@@ -386,4 +388,188 @@ const mockGqlFetch = () => mockRequester(gqlRequestMatchesMock, (operation, vari
     Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
     Context: ${JSON.stringify(context, null, 2)}`);
 
-export { RespondWith, adapters, fixtures, mockFetch, mockGqlFetch, setup as setupFixtures };
+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.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.createElement(InterceptRequests, {
+      interceptor: interceptor
+    }, currentChildren);
+  }
+
+  return React.createElement(React.Fragment, null, currentChildren);
+};
+
+const defaultConfig$1 = null;
+const adapter$1 = (children, config) => React.createElement(React.Fragment, null, React.createElement("div", {
+  id: config,
+  "data-test-id": config
+}), children);
+
+const defaultConfig = {
+  location: "/"
+};
+
+const maybeWithRoute = (children, path) => {
+  if (path == null) {
+    return children;
+  }
+
+  return React.createElement(Switch, null, React.createElement(Route, {
+    exact: true,
+    path: path
+  }, children), React.createElement(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.createElement(StaticRouter, {
+      location: config.location,
+      context: {}
+    }, wrappedWithRoute);
+  }
+
+  if (typeof config.location !== "undefined") {
+    return React.createElement(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.createElement(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({}, defaultConfigs, configs);
+
+    const harnessedComponent = React.forwardRef((props, ref) => renderAdapters(adapters, fullConfig, React.createElement(Component, _extends({}, 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);
+
+export { RespondWith, adapters$1 as fixtureAdapters, fixtures, adapters as harnessAdapters, hookHarness, makeHookHarness, makeTestHarness, mockFetch, mockGqlFetch, setup as setupFixtures, testHarness };