@khanacademy/wonder-blocks-testing 1.0.0 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @khanacademy/wonder-blocks-testing
 
+## 2.0.0
+
+### Major Changes
+
+-   274caaac: Remove isolateModules (now implemented by @khanacademy/wonder-stuff-testing), export GQL framework, export fixture framework types
+
+### Patch Changes
+
+-   @khanacademy/wonder-blocks-data@3.1.2
+
 ## 1.0.0
 
 ### Major Changes

package/dist/es/index.js

@@ -319,36 +319,212 @@ const fixtures = (options, fn) => {
   return group.closeGroup(combinedAdapterOptions);
 };
 
-// Opt this file out of coverage because it's super hard to test.
+const safeHasOwnProperty = (obj, prop) => // Flow really shouldn't be raising this error here.
+// $FlowFixMe[method-unbinding]
+Object.prototype.hasOwnProperty.call(obj, prop); // TODO(somewhatabstract, FEI-4268): use a third-party library to do this and
+// possibly make it also support the jest `jest.objectContaining` type matching
+// to simplify mock declaration (note that it would need to work in regular
+// tests and stories/fixtures).
 
-/* istanbul ignore file */
+
+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 they don't represent the same operation, then they can't match.
+  // NOTE: Operations can include more fields than id and type, but we only
+  // care about id and type. The rest is ignored.
+  if (mock.operation.id !== operation.id || mock.operation.type !== operation.type) {
+    return false;
+  } // We do a loose match, so if the lhs doesn't define variables,
+  // we just assume it matches everything.
+
+
+  if (mock.variables != null) {
+    // Variables have to match.
+    if (!areObjectsEqual(mock.variables, variables)) {
+      return false;
+    }
+  } // We do a loose match, so if the lhs doesn't define context,
+  // we just assume it matches everything.
+
+
+  if (mock.context != null) {
+    // Context has to match.
+    if (!areObjectsEqual(mock.context, context)) {
+      return false;
+    }
+  } // If we get here, we have a match.
+
+
+  return true;
+};
 
 /**
- * Isolate imports within a given action using jest.isolateModules.
- *
- * This is a helper for the `jest.isolateModules` API, allowing
- * code to avoid the clunky closure syntax in their tests.
- *
- * @param {() => T} action The action that contains the isolated module imports.
- * We do it this way so that any `require` calls are relative to the calling
- * code and not this function. Note that we don't support promises here to
- * discourage dynamic `import` use, which doesn't play well with standard
- * jest yet.
+ * Helpers to define rejection states for mocking GQL requests.
  */
-const isolateModules = action => {
-  if (typeof jest === "undefined") {
-    throw new Error(`jest is not available in global scope`);
+const RespondWith = Object.freeze({
+  data: data => ({
+    type: "data",
+    data
+  }),
+  unparseableBody: () => ({
+    type: "parse"
+  }),
+  abortedRequest: () => ({
+    type: "abort"
+  }),
+  errorStatusCode: statusCode => {
+    if (statusCode < 300) {
+      throw new Error(`${statusCode} is not a valid error status code`);
+    }
+
+    return {
+      type: "status",
+      statusCode
+    };
+  },
+  nonGraphQLBody: () => ({
+    type: "invalid"
+  }),
+  graphQLErrors: errorMessages => ({
+    type: "graphql",
+    errors: errorMessages
+  })
+});
+/**
+ * Turns an ErrorResponse value in an actual Response that will invoke
+ * that error.
+ */
+
+const makeGqlMockResponse = response => {
+  switch (response.type) {
+    case "data":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          data: response.data
+        }))
+      });
+
+    case "parse":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve("INVALID JSON")
+      });
+
+    case "abort":
+      const abortError = new Error("Mock request aborted");
+      abortError.name = "AbortError";
+      return Promise.reject(abortError);
+
+    case "status":
+      return Promise.resolve({
+        status: response.statusCode,
+        text: () => Promise.resolve(JSON.stringify({}))
+      });
+
+    case "invalid":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          valid: "json",
+          that: "is not a valid graphql response"
+        }))
+      });
+
+    case "graphql":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          errors: response.errors.map(e => ({
+            message: e
+          }))
+        }))
+      });
+
+    default:
+      throw new Error(`Unknown response type: ${response.type}`);
   }
+};
 
-  let result = undefined;
-  jest.isolateModules(() => {
-    result = action();
-  }); // We know that we'll have a result of the appropriate type at this point.
-  // We could use a promise to make everything happy, but this doesn't need
-  // to be async, so why bother.
-  // $FlowIgnore[incompatible-return]
+/**
+ * A mock for the fetch function passed to GqlRouter.
+ */
+const mockGqlFetch = () => {
+  // We want this to work in jest and in fixtures to make life easy for folks.
+  // This is the array of mocked operations that we will traverse and
+  // manipulate.
+  const mocks = []; // What we return has to be a drop in for the fetch function that is
+  // provided to `GqlRouter` which is how folks will then use this mock.
+
+  const gqlFetchMock = (operation, variables, context) => {
+    // Iterate our mocked operations and find the first one that matches.
+    for (const mock of mocks) {
+      if (mock.onceOnly && mock.used) {
+        // This is a once-only mock and it has been used, so skip it.
+        continue;
+      }
+
+      if (gqlRequestMatchesMock(mock.operation, operation, variables, context)) {
+        mock.used = true;
+        return mock.response();
+      }
+    } // Default is to reject with some helpful info on what request
+    // we rejected.
+
+
+    return Promise.reject(new Error(`No matching GraphQL mock response found for request:
+    Operation: ${operation.type} ${operation.id}
+    Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
+    Context: ${JSON.stringify(context, null, 2)}`));
+  };
+
+  const addMockedOperation = (operation, response, onceOnly) => {
+    const mockResponse = () => makeGqlMockResponse(response);
+
+    mocks.push({
+      operation,
+      response: mockResponse,
+      onceOnly,
+      used: false
+    });
+    return gqlFetchMock;
+  };
+
+  gqlFetchMock.mockOperation = (operation, response) => addMockedOperation(operation, response, false);
+
+  gqlFetchMock.mockOperationOnce = (operation, response) => addMockedOperation(operation, response, true);
 
-  return result;
+  return gqlFetchMock;
 };
 
-export { adapters, fixtures, isolateModules, setup as setupFixtures };
+export { RespondWith, adapters, fixtures, mockGqlFetch, setup as setupFixtures };

package/dist/index.js

@@ -82,7 +82,7 @@ module.exports =
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = 12);
+/******/ 	return __webpack_require__(__webpack_require__.s = 14);
 /******/ })
 /************************************************************************/
 /******/ ([
@@ -117,32 +117,127 @@ const getConfiguration = () => {
 
 /***/ }),
 /* 1 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return RespondWith; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "b", function() { return makeGqlMockResponse; });
+/**
+ * Helpers to define rejection states for mocking GQL requests.
+ */
+const RespondWith = Object.freeze({
+  data: data => ({
+    type: "data",
+    data
+  }),
+  unparseableBody: () => ({
+    type: "parse"
+  }),
+  abortedRequest: () => ({
+    type: "abort"
+  }),
+  errorStatusCode: statusCode => {
+    if (statusCode < 300) {
+      throw new Error(`${statusCode} is not a valid error status code`);
+    }
+
+    return {
+      type: "status",
+      statusCode
+    };
+  },
+  nonGraphQLBody: () => ({
+    type: "invalid"
+  }),
+  graphQLErrors: errorMessages => ({
+    type: "graphql",
+    errors: errorMessages
+  })
+});
+/**
+ * Turns an ErrorResponse value in an actual Response that will invoke
+ * that error.
+ */
+
+const makeGqlMockResponse = response => {
+  switch (response.type) {
+    case "data":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          data: response.data
+        }))
+      });
+
+    case "parse":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve("INVALID JSON")
+      });
+
+    case "abort":
+      const abortError = new Error("Mock request aborted");
+      abortError.name = "AbortError";
+      return Promise.reject(abortError);
+
+    case "status":
+      return Promise.resolve({
+        status: response.statusCode,
+        text: () => Promise.resolve(JSON.stringify({}))
+      });
+
+    case "invalid":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          valid: "json",
+          that: "is not a valid graphql response"
+        }))
+      });
+
+    case "graphql":
+      return Promise.resolve({
+        status: 200,
+        text: () => Promise.resolve(JSON.stringify({
+          errors: response.errors.map(e => ({
+            message: e
+          }))
+        }))
+      });
+
+    default:
+      throw new Error(`Unknown response type: ${response.type}`);
+  }
+};
+
+/***/ }),
+/* 2 */
 /***/ (function(module, exports) {
 
 module.exports = require("react");
 
 /***/ }),
-/* 2 */
+/* 3 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 __webpack_require__.r(__webpack_exports__);
-/* harmony import */ var _storybook_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
+/* harmony import */ var _storybook_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "storybook", function() { return _storybook_js__WEBPACK_IMPORTED_MODULE_0__["a"]; });
 
 
 
 /***/ }),
-/* 3 */
+/* 4 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return getAdapter; });
-/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
-/* harmony import */ var _storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(6);
+/* harmony import */ var _storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(7);
 /* harmony import */ var _storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_storybook_addon_actions__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _adapter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7);
+/* harmony import */ var _adapter_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8);
 
 
 
@@ -215,15 +310,15 @@ const getAdapter = (MountingComponent = null) => new _adapter_js__WEBPACK_IMPORT
 });
 
 /***/ }),
-/* 4 */
+/* 5 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return fixtures; });
-/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1);
+/* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
 /* harmony import */ var react__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(react__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _setup_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);
-/* harmony import */ var _combine_options_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(9);
+/* harmony import */ var _combine_options_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10);
 
 
 
@@ -286,56 +381,80 @@ const fixtures = (options, fn) => {
 };
 
 /***/ }),
-/* 5 */
+/* 6 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return isolateModules; });
-// Opt this file out of coverage because it's super hard to test.
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return mockGqlFetch; });
+/* harmony import */ var _gql_request_matches_mock_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(13);
+/* harmony import */ var _make_gql_mock_response_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1);
+
 
-/* istanbul ignore file */
 
 /**
- * Isolate imports within a given action using jest.isolateModules.
- *
- * This is a helper for the `jest.isolateModules` API, allowing
- * code to avoid the clunky closure syntax in their tests.
- *
- * @param {() => T} action The action that contains the isolated module imports.
- * We do it this way so that any `require` calls are relative to the calling
- * code and not this function. Note that we don't support promises here to
- * discourage dynamic `import` use, which doesn't play well with standard
- * jest yet.
+ * A mock for the fetch function passed to GqlRouter.
  */
-const isolateModules = action => {
-  if (typeof jest === "undefined") {
-    throw new Error(`jest is not available in global scope`);
-  }
+const mockGqlFetch = () => {
+  // We want this to work in jest and in fixtures to make life easy for folks.
+  // This is the array of mocked operations that we will traverse and
+  // manipulate.
+  const mocks = []; // What we return has to be a drop in for the fetch function that is
+  // provided to `GqlRouter` which is how folks will then use this mock.
+
+  const gqlFetchMock = (operation, variables, context) => {
+    // Iterate our mocked operations and find the first one that matches.
+    for (const mock of mocks) {
+      if (mock.onceOnly && mock.used) {
+        // This is a once-only mock and it has been used, so skip it.
+        continue;
+      }
+
+      if (Object(_gql_request_matches_mock_js__WEBPACK_IMPORTED_MODULE_0__[/* gqlRequestMatchesMock */ "a"])(mock.operation, operation, variables, context)) {
+        mock.used = true;
+        return mock.response();
+      }
+    } // Default is to reject with some helpful info on what request
+    // we rejected.
 
-  let result = undefined;
-  jest.isolateModules(() => {
-    result = action();
-  }); // We know that we'll have a result of the appropriate type at this point.
-  // We could use a promise to make everything happy, but this doesn't need
-  // to be async, so why bother.
-  // $FlowIgnore[incompatible-return]
 
-  return result;
+    return Promise.reject(new Error(`No matching GraphQL mock response found for request:
+    Operation: ${operation.type} ${operation.id}
+    Variables: ${variables == null ? "None" : JSON.stringify(variables, null, 2)}
+    Context: ${JSON.stringify(context, null, 2)}`));
+  };
+
+  const addMockedOperation = (operation, response, onceOnly) => {
+    const mockResponse = () => Object(_make_gql_mock_response_js__WEBPACK_IMPORTED_MODULE_1__[/* makeGqlMockResponse */ "b"])(response);
+
+    mocks.push({
+      operation,
+      response: mockResponse,
+      onceOnly,
+      used: false
+    });
+    return gqlFetchMock;
+  };
+
+  gqlFetchMock.mockOperation = (operation, response) => addMockedOperation(operation, response, false);
+
+  gqlFetchMock.mockOperationOnce = (operation, response) => addMockedOperation(operation, response, true);
+
+  return gqlFetchMock;
 };
 
 /***/ }),
-/* 6 */
+/* 7 */
 /***/ (function(module, exports) {
 
 module.exports = require("@storybook/addon-actions");
 
 /***/ }),
-/* 7 */
+/* 8 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return Adapter; });
-/* harmony import */ var _adapter_group_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8);
+/* harmony import */ var _adapter_group_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9);
 
 
 /**
@@ -390,7 +509,7 @@ class Adapter {
 }
 
 /***/ }),
-/* 8 */
+/* 9 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -455,12 +574,12 @@ class AdapterGroup {
 }
 
 /***/ }),
-/* 9 */
+/* 10 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return combineOptions; });
-/* harmony import */ var _combine_top_level_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(10);
+/* harmony import */ var _combine_top_level_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
 
 /**
  * Combine one or more objects into a single object.
@@ -485,12 +604,12 @@ const combineOptions = (...toBeCombined) => {
 };
 
 /***/ }),
-/* 10 */
+/* 11 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return combineTopLevel; });
-/* harmony import */ var _khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(11);
+/* harmony import */ var _khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(12);
 /* harmony import */ var _khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_khanacademy_wonder_stuff_core__WEBPACK_IMPORTED_MODULE_0__);
 
 /**
@@ -531,34 +650,112 @@ const combineTopLevel = (val1, val2) => {
 };
 
 /***/ }),
-/* 11 */
+/* 12 */
 /***/ (function(module, exports) {
 
 module.exports = require("@khanacademy/wonder-stuff-core");
 
 /***/ }),
-/* 12 */
+/* 13 */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "a", function() { return gqlRequestMatchesMock; });
+const safeHasOwnProperty = (obj, prop) => // Flow really shouldn't be raising this error here.
+// $FlowFixMe[method-unbinding]
+Object.prototype.hasOwnProperty.call(obj, prop); // TODO(somewhatabstract, FEI-4268): use a third-party library to do this and
+// possibly make it also support the jest `jest.objectContaining` type matching
+// to simplify mock declaration (note that it would need to work in regular
+// tests and stories/fixtures).
+
+
+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 they don't represent the same operation, then they can't match.
+  // NOTE: Operations can include more fields than id and type, but we only
+  // care about id and type. The rest is ignored.
+  if (mock.operation.id !== operation.id || mock.operation.type !== operation.type) {
+    return false;
+  } // We do a loose match, so if the lhs doesn't define variables,
+  // we just assume it matches everything.
+
+
+  if (mock.variables != null) {
+    // Variables have to match.
+    if (!areObjectsEqual(mock.variables, variables)) {
+      return false;
+    }
+  } // We do a loose match, so if the lhs doesn't define context,
+  // we just assume it matches everything.
+
+
+  if (mock.context != null) {
+    // Context has to match.
+    if (!areObjectsEqual(mock.context, context)) {
+      return false;
+    }
+  } // If we get here, we have a match.
+
+
+  return true;
+};
+
+/***/ }),
+/* 14 */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 __webpack_require__.r(__webpack_exports__);
-/* harmony import */ var _fixtures_adapters_adapters_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(2);
+/* harmony import */ var _fixtures_adapters_adapters_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3);
 /* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "adapters", function() { return _fixtures_adapters_adapters_js__WEBPACK_IMPORTED_MODULE_0__; });
-/* harmony import */ var _fixtures_fixtures_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(4);
+/* harmony import */ var _fixtures_fixtures_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5);
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "fixtures", function() { return _fixtures_fixtures_js__WEBPACK_IMPORTED_MODULE_1__["a"]; });
 
 /* harmony import */ var _fixtures_setup_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(0);
 /* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "setupFixtures", function() { return _fixtures_setup_js__WEBPACK_IMPORTED_MODULE_2__["b"]; });
 
-/* harmony import */ var _jest_isolate_modules_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(5);
-/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "isolateModules", function() { return _jest_isolate_modules_js__WEBPACK_IMPORTED_MODULE_3__["a"]; });
+/* harmony import */ var _gql_mock_gql_fetch_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(6);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "mockGqlFetch", function() { return _gql_mock_gql_fetch_js__WEBPACK_IMPORTED_MODULE_3__["a"]; });
+
+/* harmony import */ var _gql_make_gql_mock_response_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(1);
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "RespondWith", function() { return _gql_make_gql_mock_response_js__WEBPACK_IMPORTED_MODULE_4__["a"]; });
 
 // Fixtures framework
 
 
 
- // Jest
-// TODO(somewhatabstract): To be moved to wonder stuff
+
+// GraphQL framework
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@khanacademy/wonder-blocks-testing",
-    "version": "1.0.0",
+    "version": "2.0.0",
     "design": "v1",
     "publishConfig": {
         "access": "public"
@@ -14,15 +14,16 @@
     },
     "dependencies": {
         "@babel/runtime": "^7.16.3",
-        "@khanacademy/wonder-blocks-data": "^3.1.1"
+        "@khanacademy/wonder-blocks-data": "^3.1.2"
     },
     "peerDependencies": {
         "@khanacademy/wonder-stuff-core": "^0.1.2",
+        "@khanacademy/wonder-stuff-testing": "^0.0.2",
         "@storybook/addon-actions": "^6.4.8",
         "react": "16.14.0"
     },
     "devDependencies": {
-        "wb-dev-build-settings": "^0.2.0"
+        "wb-dev-build-settings": "^0.3.0"
     },
     "author": "",
     "license": "MIT"

package/src/fixtures/__tests__/setup.test.js

@@ -1,10 +1,10 @@
 // @flow
-import {isolateModules} from "../../jest/isolate-modules.js";
+import {jest as wst} from "@khanacademy/wonder-stuff-testing";
 
 describe("#getConfiguration", () => {
     it("should return the configuration passed during setup", () => {
         // Arrange
-        const {setup, getConfiguration} = isolateModules(() =>
+        const {setup, getConfiguration} = wst.isolateModules(() =>
             require("../setup.js"),
         );
         const configuration = {
@@ -25,7 +25,9 @@ describe("#getConfiguration", () => {
 
     it("should throw if setup has not been performed", () => {
         // Arrange
-        const {getConfiguration} = isolateModules(() => require("../setup.js"));
+        const {getConfiguration} = wst.isolateModules(() =>
+            require("../setup.js"),
+        );
 
         // Act
         const underTest = () => getConfiguration();
@@ -40,7 +42,7 @@ describe("#getConfiguration", () => {
 describe("#setup", () => {
     it("should set the configuration returned by getConfiguration", () => {
         // Arrange
-        const {setup, getConfiguration} = isolateModules(() =>
+        const {setup, getConfiguration} = wst.isolateModules(() =>
             require("../setup.js"),
         );
         const configuration1 = {

package/src/index.js

@@ -4,7 +4,21 @@
 export * as adapters from "./fixtures/adapters/adapters.js";
 export {fixtures} from "./fixtures/fixtures.js";
 export {setup as setupFixtures} from "./fixtures/setup.js";
+export type {
+    Adapter,
+    AdapterFactory,
+    AdapterFixtureOptions,
+    AdapterGroup,
+    AdapterGroupOptions,
+    AdapterOptions,
+    Configuration,
+    CustomWrapperProps,
+    GetPropsOptions,
+    FixturesOptions,
+} from "./fixtures/types.js";
 
-// Jest
-// TODO(somewhatabstract): To be moved to wonder stuff
-export {isolateModules} from "./jest/isolate-modules.js";
+// GraphQL framework
+export {mockGqlFetch} from "./gql/mock-gql-fetch.js";
+export type {GqlMockResponse} from "./gql/make-gql-mock-response.js";
+export {RespondWith} from "./gql/make-gql-mock-response.js";
+export type {GqlFetchMockFn, GqlMock, GqlMockOperation} from "./gql/types.js";

package/src/jest/isolate-modules.js

@@ -1,31 +0,0 @@
-// @flow
-// Opt this file out of coverage because it's super hard to test.
-/* istanbul ignore file */
-
-/**
- * Isolate imports within a given action using jest.isolateModules.
- *
- * This is a helper for the `jest.isolateModules` API, allowing
- * code to avoid the clunky closure syntax in their tests.
- *
- * @param {() => T} action The action that contains the isolated module imports.
- * We do it this way so that any `require` calls are relative to the calling
- * code and not this function. Note that we don't support promises here to
- * discourage dynamic `import` use, which doesn't play well with standard
- * jest yet.
- */
-export const isolateModules = <T>(action: () => T): T => {
-    if (typeof jest === "undefined") {
-        throw new Error(`jest is not available in global scope`);
-    }
-
-    let result = undefined;
-    jest.isolateModules(() => {
-        result = action();
-    });
-    // We know that we'll have a result of the appropriate type at this point.
-    // We could use a promise to make everything happy, but this doesn't need
-    // to be async, so why bother.
-    // $FlowIgnore[incompatible-return]
-    return result;
-};