@khanacademy/wonder-blocks-testing 10.1.1 → 11.0.0

package/src/__tests__/respond-with.test.ts

@@ -1,524 +0,0 @@
-import {SettleController} from "../settle-controller";
-import {RespondWith} from "../respond-with";
-
-describe("RespondWith", () => {
-    describe("#text.toPromise", () => {
-        it("should respond with the given text", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.text("SOME TEXT").toPromise();
-            const result = await response.text();
-
-            // Assert
-            expect(result).toBe("SOME TEXT");
-        });
-
-        it("should respond with the given status code", async () => {
-            // Arrange
-
-            // Act
-            const result = await RespondWith.text("SOME TEXT", 204).toPromise();
-
-            // Assert
-            expect(result).toHaveProperty("status", 204);
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.text(
-                "SIGNALLED",
-                200,
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.text(
-                "SIGNALLED",
-                200,
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("SIGNALLED");
-        });
-    });
-
-    describe("#json.toPromise", () => {
-        it("should respond with the given json", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.json({
-                some: "json",
-            }).toPromise();
-            const result = await response.json();
-
-            // Assert
-            expect(result).toStrictEqual({some: "json"});
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.json(
-                {result: "SIGNALLED"},
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.json(
-                {result: "SIGNALLED"},
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.json();
-
-            // Assert
-            expect(result).toStrictEqual({result: "SIGNALLED"});
-        });
-    });
-
-    describe("#graphQLData", () => {
-        it("should respond with the given GraphQL data", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.graphQLData({
-                some: "json",
-            }).toPromise();
-            const result = await response.json();
-
-            // Assert
-            expect(result).toStrictEqual({data: {some: "json"}});
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.graphQLData(
-                {result: "SIGNALLED"},
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.graphQLData(
-                {result: "SIGNALLED"},
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.json();
-
-            // Assert
-            expect(result).toStrictEqual({data: {result: "SIGNALLED"}});
-        });
-    });
-
-    describe("#unparseableBody", () => {
-        it("should reject JSON as unparseable", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.unparseableBody().toPromise();
-            const act = response.json();
-
-            // Assert
-            await expect(act).rejects.toThrowErrorMatchingInlineSnapshot(
-                `"invalid json response body at  reason: Unexpected token 'I', "INVALID JSON" is not valid JSON"`,
-            );
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.unparseableBody(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.unparseableBody(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const act = firstResponse.json();
-
-            // Assert
-            await expect(act).rejects.toThrowError();
-        });
-    });
-
-    describe("#abortedRequest", () => {
-        it("should reject with AbortError", async () => {
-            // Arrange
-
-            // Act
-            const act = RespondWith.abortedRequest().toPromise();
-
-            // Assert
-            await expect(act).rejects.toThrowErrorMatchingInlineSnapshot(
-                `"Mock request aborted"`,
-            );
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.abortedRequest(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const act = Promise.race([settleableResponse, otherResponse]);
-
-            // Assert
-            await expect(act).resolves;
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.abortedRequest(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const act = Promise.race([settleableResponse, otherResponse]);
-
-            // Assert
-            await expect(act).rejects.toThrowError();
-        });
-    });
-
-    describe("#reject", () => {
-        it("should reject with AbortError", async () => {
-            // Arrange
-
-            // Act
-            const act = RespondWith.reject(new Error("BOOM!")).toPromise();
-
-            // Assert
-            await expect(act).rejects.toThrowErrorMatchingInlineSnapshot(
-                `"BOOM!"`,
-            );
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.reject(
-                new Error("BOOM!"),
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const act = Promise.race([settleableResponse, otherResponse]);
-
-            // Assert
-            await expect(act).resolves;
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.reject(
-                new Error("BOOM!"),
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const act = Promise.race([settleableResponse, otherResponse]);
-
-            // Assert
-            await expect(act).rejects.toThrowError();
-        });
-    });
-
-    describe("#errorStatusCode", () => {
-        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"`,
-            );
-        });
-
-        it("should respond with the given status code", async () => {
-            // Arrange
-
-            // Act
-            const result = await RespondWith.errorStatusCode(400).toPromise();
-
-            // Assert
-            expect(result).toHaveProperty("status", 400);
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.errorStatusCode(
-                500,
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.errorStatusCode(
-                500,
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const result = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-
-            // Assert
-            expect(result).toHaveProperty("status", 500);
-        });
-    });
-
-    describe("#nonGraphQLBody", () => {
-        it("should respond with valid json", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.nonGraphQLBody().toPromise();
-            const act = response.json();
-
-            // Assert
-            await expect(act).resolves.not.toThrow();
-        });
-
-        it("should respond with JSON that is not a valid GraphQL response", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.nonGraphQLBody().toPromise();
-            const result = await response.json();
-
-            // Assert
-            expect(result).toMatchInlineSnapshot(`
-                {
-                  "that": "is not a valid graphql response",
-                  "valid": "json",
-                }
-            `);
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.nonGraphQLBody(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.nonGraphQLBody(
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.json();
-
-            // Assert
-            expect(result).toStrictEqual({
-                valid: "json",
-                that: "is not a valid graphql response",
-            });
-        });
-    });
-
-    describe("#graphQLErrors", () => {
-        it("should respond with the given GraphQL errors", async () => {
-            // Arrange
-
-            // Act
-            const response = await RespondWith.graphQLErrors([
-                "BOOM!",
-                "BANG!",
-            ]).toPromise();
-            const result = await response.json();
-
-            // Assert
-            expect(result).toStrictEqual({
-                errors: [{message: "BOOM!"}, {message: "BANG!"}],
-            });
-        });
-
-        it("should not settle if the signal is not raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.graphQLErrors(
-                ["BOOM!", "BANG!"],
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.text();
-
-            // Assert
-            expect(result).toBe("NO SIGNAL");
-        });
-
-        it("should settle if the signal is raised", async () => {
-            // Arrange
-            const settleController = new SettleController();
-            const settleableResponse = RespondWith.graphQLErrors(
-                ["SIGNALLED"],
-                settleController.signal,
-            ).toPromise();
-            const otherResponse = RespondWith.text("NO SIGNAL").toPromise();
-
-            // Act
-            settleController.settle();
-            const firstResponse = await Promise.race([
-                settleableResponse,
-                otherResponse,
-            ]);
-            const result = await firstResponse.json();
-
-            // Assert
-            expect(result).toStrictEqual({
-                errors: [{message: "SIGNALLED"}],
-            });
-        });
-    });
-});

package/src/__tests__/response-impl.test.js

@@ -1,47 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-import * as wst from "@khanacademy/wonder-stuff-testing";
-
-describe("ResponseImpl", () => {
-    const globalResponse = globalThis.Response;
-
-    beforeEach(() => {
-        if (globalResponse) {
-            delete globalThis.Response;
-        }
-    });
-
-    afterEach(() => {
-        if (globalResponse) {
-            globalThis.Response = globalResponse;
-        } else {
-            delete globalThis.Response;
-        }
-    });
-
-    it("should use Response from node-fetch if Response does not exist", () => {
-        // Arrange
-
-        // Act
-        const {ResponseImpl: result, NodeFetchResponse} =
-            wst.jest.isolateModules(() => ({
-                ResponseImpl: require("../response-impl").ResponseImpl,
-                NodeFetchResponse: require("node-fetch").Response,
-            }));
-
-        // Assert
-        expect(result).toBe(NodeFetchResponse);
-    });
-
-    it("should return the existing Response type if it exists", () => {
-        // Arrange
-        globalThis.Response = class CustomResponse {};
-
-        // Act
-        const result = wst.jest.isolateModules(
-            () => require("../response-impl").ResponseImpl,
-        );
-
-        // Assert
-        expect(result).toBe(globalThis.Response);
-    });
-});

package/src/__tests__/settle-controller.test.ts

@@ -1,28 +0,0 @@
-import {SettleController} from "../settle-controller";
-import {SettleSignal} from "../settle-signal";
-
-describe("SettleController", () => {
-    it("should have a signal", () => {
-        // Arrange
-
-        // Act
-        const result = new SettleController();
-
-        // Assert
-        expect(result).toHaveProperty("signal", expect.any(SettleSignal));
-    });
-
-    describe("#settle", () => {
-        it("should settle the signal", () => {
-            // Arrange
-            const controller = new SettleController();
-            const signal = controller.signal;
-
-            // Act
-            controller.settle();
-
-            // Assert
-            expect(signal.settled).toBe(true);
-        });
-    });
-});

package/src/__tests__/settle-signal.test.ts

@@ -1,104 +0,0 @@
-import {SettleSignal} from "../settle-signal";
-
-describe("SettleSignal", () => {
-    it("should extend EventTarget", () => {
-        // Arrange
-
-        // Act
-        const result = new SettleSignal();
-
-        // Assert
-        expect(result).toBeInstanceOf(EventTarget);
-    });
-
-    it("should start with settled = false", () => {
-        // Arrange
-
-        // Act
-        const result = new SettleSignal();
-
-        // Assert
-        expect(result).toHaveProperty("settled", false);
-    });
-
-    it("should invoke the passed function with a function", () => {
-        // Arrange
-        const setSettleFn = jest.fn();
-
-        // Act
-        // eslint-disable-next-line no-new
-        new SettleSignal(setSettleFn);
-
-        // Assert
-        expect(setSettleFn).toHaveBeenCalledWith(expect.any(Function));
-    });
-
-    describe("setSettleFn argument", () => {
-        it("should set settled to true", () => {
-            // Arrange
-            const setSettleFn = jest.fn();
-            const signal = new SettleSignal(setSettleFn);
-            const settle = setSettleFn.mock.calls[0][0];
-
-            // Act
-            settle();
-
-            // Assert
-            expect(signal.settled).toBe(true);
-        });
-
-        it("should raise the settled event", () => {
-            // Arrange
-            const setSettleFn = jest.fn();
-            const signal = new SettleSignal(setSettleFn);
-            const settle = setSettleFn.mock.calls[0][0];
-            const handler = jest.fn();
-            signal.addEventListener("settled", handler);
-
-            // Act
-            settle();
-
-            // Assert
-            expect(handler).toHaveBeenCalled();
-        });
-
-        it("should throw if the signal has already been settled", () => {
-            // Arrange
-            const setSettleFn = jest.fn();
-            // eslint-disable-next-line no-new
-            new SettleSignal(setSettleFn);
-            const settle = setSettleFn.mock.calls[0][0];
-            settle();
-
-            // Act
-            const result = () => settle();
-
-            // Assert
-            expect(result).toThrowErrorMatchingInlineSnapshot(
-                `"SettleSignal already settled"`,
-            );
-        });
-    });
-
-    describe("#SettleSignal.settle", () => {
-        it("should return a SettleSignal", () => {
-            // Arrange
-
-            // Act
-            const result = SettleSignal.settle();
-
-            // Assert
-            expect(result).toBeInstanceOf(SettleSignal);
-        });
-
-        it("should return a SettleSignal that is already settled", () => {
-            // Arrange
-
-            // Act
-            const result = SettleSignal.settle();
-
-            // Assert
-            expect(result).toHaveProperty("settled", true);
-        });
-    });
-});