@khanacademy/wonder-blocks-testing 0.0.2 → 2.0.2

package/src/gql/__tests__/gql-request-matches-mock.test.js

@@ -0,0 +1,235 @@
+// @flow
+import {gqlRequestMatchesMock} from "../gql-request-matches-mock.js";
+
+describe("#gqlRequestMatchesMock", () => {
+    it("should return false if operation types don't match", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+        };
+        const operation = {
+            id: "foo",
+            type: "mutation",
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(mock, operation, null, {});
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    it("should return false if operation ids don't match", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(
+            mock,
+            {
+                id: "bar",
+                type: "query",
+            },
+            null,
+            {},
+        );
+
+        // Assert
+        expect(result).toBe(false);
+    });
+
+    it.each([{foo: "bar"}, {foo: "baz", anExtra: "property"}, null])(
+        "should return false if variables don't match",
+        (variables) => {
+            // Arrange
+            const mock = {
+                operation: {
+                    id: "foo",
+                    type: "query",
+                },
+                variables: {
+                    foo: "baz",
+                },
+            };
+            const operation = {
+                id: "foo",
+                type: "query",
+            };
+
+            // Act
+            const result = gqlRequestMatchesMock(
+                mock,
+                operation,
+                variables,
+                {},
+            );
+
+            // Assert
+            expect(result).toBe(false);
+        },
+    );
+
+    it.each([{a: "context"}, null])(
+        "should return false if contexts don't match",
+        (context) => {
+            // Arrange
+            const mock = {
+                operation: {
+                    id: "foo",
+                    type: "query",
+                },
+                variables: {
+                    foo: "bar",
+                },
+                context: {
+                    mock: "context",
+                },
+            };
+            const operation = {
+                id: "foo",
+                type: "query",
+            };
+            const variables = {
+                foo: "bar",
+            };
+
+            // Act
+            const result = gqlRequestMatchesMock(
+                mock,
+                operation,
+                variables,
+                context,
+            );
+
+            // Assert
+            expect(result).toBe(false);
+        },
+    );
+
+    it("should return true if operation matches and mock does not include context nor variables, regardless of comparison operation variables and context", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(
+            mock,
+            {
+                id: "foo",
+                type: "query",
+            },
+            {a: "variable"},
+            {my: "context"},
+        );
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true if operation and variables match and there is no mock context", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+            variables: {
+                foo: "bar",
+            },
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(
+            mock,
+            {
+                id: "foo",
+                type: "query",
+            },
+            {
+                foo: "bar",
+            },
+            {my: "context"},
+        );
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true if operation and context match and there are no mock variables", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+            context: {
+                foo: "bar",
+            },
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(
+            mock,
+            {
+                id: "foo",
+                type: "query",
+            },
+            {a: "variable"},
+            {
+                foo: "bar",
+            },
+        );
+
+        // Assert
+        expect(result).toBe(true);
+    });
+
+    it("should return true if everything matches", () => {
+        // Arrange
+        const mock = {
+            operation: {
+                id: "foo",
+                type: "query",
+            },
+            variables: {
+                foo: "bar",
+            },
+            context: {
+                foo: "bar",
+            },
+        };
+        const operation = {
+            id: "foo",
+            type: "query",
+        };
+        const variables = {
+            foo: "bar",
+        };
+        const context = {
+            foo: "bar",
+        };
+
+        // Act
+        const result = gqlRequestMatchesMock(
+            mock,
+            operation,
+            {...variables},
+            {...context},
+        );
+
+        // Assert
+        expect(result).toBe(true);
+    });
+});

package/src/gql/__tests__/make-gql-mock-response.test.js

@@ -0,0 +1,298 @@
+// @flow
+import {RespondWith, makeGqlMockResponse} from "../make-gql-mock-response.js";
+
+describe("RespondWith", () => {
+    describe("#data", () => {
+        it("should have type data", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.data({});
+
+            // Assert
+            expect(result).toHaveProperty("type", "data");
+        });
+
+        it("should include the given data", () => {
+            // Arrange
+            const data = {
+                foo: "bar",
+            };
+
+            // Act
+            const result = RespondWith.data(data);
+
+            // Assert
+            expect(result).toHaveProperty("data", data);
+        });
+    });
+
+    describe("#unparseableBody", () => {
+        it("should have type parse", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.unparseableBody();
+
+            // Assert
+            expect(result).toHaveProperty("type", "parse");
+        });
+    });
+
+    describe("#abortedRequest", () => {
+        it("should have type abort", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.abortedRequest();
+
+            // Assert
+            expect(result).toHaveProperty("type", "abort");
+        });
+    });
+
+    describe("#errorStatusCode", () => {
+        it("should have type status", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.errorStatusCode(400);
+
+            // Assert
+            expect(result).toHaveProperty("type", "status");
+        });
+
+        it("should include the given status code", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.errorStatusCode(400);
+
+            // Assert
+            expect(result).toHaveProperty("statusCode", 400);
+        });
+
+        it("should throw if the status code represents success", () => {
+            // Arrange
+
+            // Act
+            const result = () => RespondWith.errorStatusCode(200);
+
+            // Assert
+            expect(result).toThrowErrorMatchingInlineSnapshot(
+                `"200 is not a valid error status code"`,
+            );
+        });
+    });
+
+    describe("#nonGraphQLBody", () => {
+        it("should have type invalid", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.nonGraphQLBody();
+
+            // Assert
+            expect(result).toHaveProperty("type", "invalid");
+        });
+    });
+
+    describe("#graphQLErrors", () => {
+        it("should have type graphql", () => {
+            // Arrange
+
+            // Act
+            const result = RespondWith.graphQLErrors([]);
+
+            // Assert
+            expect(result).toHaveProperty("type", "graphql");
+        });
+
+        it("should include the given error messages", () => {
+            // Arrange
+            const errorMessages = ["foo", "bar"];
+
+            // Act
+            const result = RespondWith.graphQLErrors(errorMessages);
+
+            // Assert
+            expect(result).toHaveProperty("errors", errorMessages);
+        });
+    });
+});
+
+describe("#makeGqlErrorResponse", () => {
+    it("should throw for unknown response type", () => {
+        // Arrange
+
+        // Act
+        const result = () =>
+            makeGqlMockResponse(({type: "NOT A VALID TYPE"}: any));
+
+        // Assert
+        expect(result).toThrowErrorMatchingInlineSnapshot(
+            `"Unknown response type: NOT A VALID TYPE"`,
+        );
+    });
+
+    describe("data response", () => {
+        it("should resolve to have a successful status code", async () => {
+            // Arrange
+            const mockResponse = RespondWith.data({});
+
+            // Act
+            const result = await makeGqlMockResponse(mockResponse);
+
+            // Assert
+            expect(result.status).toBe(200);
+        });
+
+        it("should resolve to response with text() function that resolves to GraphQL data result", async () => {
+            // Arrange
+            const data = {
+                foo: "bar",
+            };
+            const mockResponse = RespondWith.data(data);
+
+            // Act
+            const response = await makeGqlMockResponse(mockResponse);
+            const result = await response.text();
+
+            // Assert
+            expect(result).toEqual(JSON.stringify({data}));
+        });
+    });
+
+    describe("unparseable body response", () => {
+        it("should resolve to have a successful status code", async () => {
+            // Arrange
+            const mockResponse = RespondWith.unparseableBody();
+
+            // Act
+            const result = await makeGqlMockResponse(mockResponse);
+
+            // Assert
+            expect(result.status).toBe(200);
+        });
+
+        it("should resolve to response with text() function that resolves to non-JSON text", async () => {
+            // Arrange
+            const mockResponse = RespondWith.unparseableBody();
+
+            // Act
+            const response = await makeGqlMockResponse(mockResponse);
+            const text = await response.text();
+            const act = () => JSON.parse(text);
+
+            // Assert
+            expect(act).toThrowError();
+        });
+    });
+
+    describe("aborted request response", () => {
+        it("should reject with error", async () => {
+            // Arrange
+            const mockResponse = RespondWith.abortedRequest();
+
+            // Act
+            const act = () => makeGqlMockResponse(mockResponse);
+
+            // Assert
+            await expect(act).rejects.toBeInstanceOf(Error);
+        });
+
+        it("should reject with an AbortError", async () => {
+            // Arrange
+            const mockResponse = RespondWith.abortedRequest();
+
+            // Act
+            const act = makeGqlMockResponse(mockResponse);
+
+            // Assert
+            await expect(act).rejects.toHaveProperty("name", "AbortError");
+        });
+    });
+
+    describe("error status code response", () => {
+        it("should resolve to have the given status code", async () => {
+            // Arrange
+            const mockResponse = RespondWith.errorStatusCode(400);
+
+            // Act
+            const result = await makeGqlMockResponse(mockResponse);
+
+            // Assert
+            expect(result.status).toBe(400);
+        });
+
+        it("should resolve to response with text() function that resolves to some parseable JSON", async () => {
+            // Arrange
+            const mockResponse = RespondWith.errorStatusCode(400);
+
+            // Act
+            const response = await makeGqlMockResponse(mockResponse);
+            const text = await response.text();
+            const act = () => JSON.parse(text);
+
+            // Assert
+            expect(act).not.toThrowError();
+        });
+    });
+
+    describe("non-graphql body response", () => {
+        it("should resolve to have a successful status code", async () => {
+            // Arrange
+            const mockResponse = RespondWith.nonGraphQLBody();
+
+            // Act
+            const result = await makeGqlMockResponse(mockResponse);
+
+            // Assert
+            expect(result.status).toBe(200);
+        });
+
+        it("should resolve to response with text() function that resolves to JSON parseable text that is not a valid GraphQL response", async () => {
+            // Arrange
+            const mockResponse = RespondWith.nonGraphQLBody();
+
+            // Act
+            const response = await makeGqlMockResponse(mockResponse);
+            const text = await response.text();
+            const result = JSON.parse(text);
+
+            // Assert
+            expect(result).not.toHaveProperty("data");
+            expect(result).not.toHaveProperty("errors");
+        });
+    });
+
+    describe("graphql error response", () => {
+        it("should resolve to have a successful status code", async () => {
+            // Arrange
+            const mockResponse = RespondWith.graphQLErrors([]);
+
+            // Act
+            const result = await makeGqlMockResponse(mockResponse);
+
+            // Assert
+            expect(result.status).toBe(200);
+        });
+
+        it("should resolve to response with text() function that resolves to GraphQL error result", async () => {
+            // Arrange
+            const errorMessages = ["foo", "bar"];
+            const mockResponse = RespondWith.graphQLErrors(errorMessages);
+
+            // Act
+            const response = await makeGqlMockResponse(mockResponse);
+            const text = await response.text();
+            const result = JSON.parse(text);
+
+            // Assert
+            expect(result).toHaveProperty("errors", [
+                {message: "foo"},
+                {message: "bar"},
+            ]);
+        });
+    });
+});