@khanacademy/wonder-blocks-testing 0.0.2 → 2.0.2

package/CHANGELOG.md

@@ -1,7 +1,44 @@
 # @khanacademy/wonder-blocks-testing
 
+## 2.0.2
+
+### Patch Changes
+
+-   Updated dependencies [6973afa2]
+    -   @khanacademy/wonder-blocks-data@3.2.0
+
+## 2.0.1
+
+### Patch Changes
+
+-   9931ae6b: Simplify GQL types
+-   Updated dependencies [9931ae6b]
+    -   @khanacademy/wonder-blocks-data@3.1.3
+
+## 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
+
+-   4ff59815: Add GraphQL fetch mock support to wonder-blocks-testing
+
+### Patch Changes
+
+-   Updated dependencies [4ff59815]
+    -   @khanacademy/wonder-blocks-data@3.1.1
+
 ## 0.0.2
+
 ### Patch Changes
 
-- d2dba67a: Implemented the fixture framework and added the storybook adapter for it
-- b7a100f2: Add the new wonder-blocks-testing package
+-   d2dba67a: Implemented the fixture framework and added the storybook adapter for it
+-   b7a100f2: Add the new wonder-blocks-testing package

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 };