@khanacademy/wonder-blocks-data 13.0.11 → 14.0.0

package/src/hooks/__tests__/use-request-interception.test.tsx

@@ -1,254 +0,0 @@
-import * as React from "react";
-import {renderHook} from "@testing-library/react-hooks";
-import InterceptRequests from "../../components/intercept-requests";
-import {useRequestInterception} from "../use-request-interception";
-
-describe("#useRequestInterception", () => {
-    it("should return a function", () => {
-        // Arrange
-
-        // Act
-        const {
-            result: {current: result},
-        } = renderHook(() => useRequestInterception("ID", jest.fn()));
-
-        // Assert
-        expect(result).toBeInstanceOf(Function);
-    });
-
-    it("should return the same function if the arguments and context don't change", () => {
-        // Arrange
-        const handler = jest.fn();
-
-        // Act
-        const wrapper = renderHook(() => useRequestInterception("ID", handler));
-        const result1 = wrapper.result.current;
-        wrapper.rerender();
-        const result2 = wrapper.result.current;
-
-        // Assert
-        expect(result1).toBe(result2);
-    });
-
-    it("should return a new function if the requestId changes", () => {
-        // Arrange
-        const handler = jest.fn();
-
-        // Act
-        const wrapper = renderHook(
-            ({requestId}: any) => useRequestInterception(requestId, handler),
-            {initialProps: {requestId: "ID"}},
-        );
-        const result1 = wrapper.result.current;
-        wrapper.rerender({requestId: "ID2"});
-        const result2 = wrapper.result.current;
-
-        // Assert
-        expect(result1).not.toBe(result2);
-    });
-
-    it("should return a new function if the handler changes", () => {
-        // Arrange
-
-        // Act
-        const wrapper = renderHook(
-            ({handler}: any) => useRequestInterception("ID", handler),
-            {initialProps: {handler: jest.fn()}},
-        );
-        const result1 = wrapper.result.current;
-        wrapper.rerender({handler: jest.fn()});
-        const result2 = wrapper.result.current;
-
-        // Assert
-        expect(result1).not.toBe(result2);
-    });
-
-    it("should return a new function if the context changes", () => {
-        // Arrange
-        const handler = jest.fn();
-        const interceptor1 = jest.fn();
-        const interceptor2 = jest.fn();
-        const Wrapper = ({children, interceptor}: any): React.ReactElement => (
-            <InterceptRequests interceptor={interceptor}>
-                {children}
-            </InterceptRequests>
-        );
-
-        // Act
-        const wrapper = renderHook(
-            () => useRequestInterception("ID", handler),
-            {wrapper: Wrapper, initialProps: {interceptor: interceptor1}},
-        );
-        const result1 = wrapper.result.current;
-        wrapper.rerender({interceptor: interceptor2});
-        const result2 = wrapper.result.current;
-
-        // Assert
-        expect(result1).not.toBe(result2);
-    });
-
-    describe("returned function", () => {
-        it("should invoke the original handler when there are no interceptors", () => {
-            // Arrange
-            const handler = jest.fn();
-            const requestId = "ID";
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception(requestId, handler));
-
-            // Act
-            interceptedHandler();
-
-            // Assert
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-
-        it("should invoke interceptors nearest to furthest", () => {
-            // Arrange
-            const handler = jest.fn();
-            const interceptorFurthest = jest.fn(() => null);
-            const interceptorNearest = jest.fn(() => null);
-            const Wrapper = ({children}: any) => (
-                <InterceptRequests interceptor={interceptorFurthest}>
-                    <InterceptRequests interceptor={interceptorNearest}>
-                        {children}
-                    </InterceptRequests>
-                </InterceptRequests>
-            );
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception("ID", handler), {
-                wrapper: Wrapper,
-            });
-
-            // Act
-            interceptedHandler();
-
-            // Assert
-            expect(interceptorNearest).toHaveBeenCalledBefore(
-                interceptorFurthest,
-            );
-        });
-
-        it("should invoke the handler last", () => {
-            // Arrange
-            const handler = jest.fn();
-            const interceptorFurthest = jest.fn(() => null);
-            const interceptorNearest = jest.fn(() => null);
-            const Wrapper = ({children}: any) => (
-                <InterceptRequests interceptor={interceptorFurthest}>
-                    <InterceptRequests interceptor={interceptorNearest}>
-                        {children}
-                    </InterceptRequests>
-                </InterceptRequests>
-            );
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception("ID", handler), {
-                wrapper: Wrapper,
-            });
-
-            // Act
-            interceptedHandler();
-
-            // Assert
-            expect(interceptorFurthest).toHaveBeenCalledBefore(handler);
-        });
-
-        it("should invoke the original handler when there all interceptors return null", () => {
-            // Arrange
-            const handler = jest.fn();
-            const interceptor1 = jest.fn(() => null);
-            const interceptor2 = jest.fn(() => null);
-            const Wrapper = ({children}: any) => (
-                <InterceptRequests interceptor={interceptor1}>
-                    <InterceptRequests interceptor={interceptor2}>
-                        {children}
-                    </InterceptRequests>
-                </InterceptRequests>
-            );
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception("ID", handler), {
-                wrapper: Wrapper,
-            });
-
-            // Act
-            interceptedHandler();
-
-            // Assert
-            expect(handler).toHaveBeenCalledTimes(1);
-        });
-
-        it("should return the result of the nearest interceptor that returns a non-null result", async () => {
-            // Arrange
-            const handler = jest
-                .fn()
-                .mockRejectedValue(
-                    new Error("This handler should have been intercepted"),
-                );
-            const interceptorFurthest = jest
-                .fn()
-                .mockRejectedValue(
-                    new Error("This interceptor should not get called"),
-                );
-            const interceptorNearest = jest
-                .fn()
-                .mockResolvedValue("INTERCEPTED_DATA");
-            const Wrapper = ({children}: any) => (
-                <InterceptRequests interceptor={interceptorFurthest}>
-                    <InterceptRequests interceptor={interceptorNearest}>
-                        {children}
-                    </InterceptRequests>
-                </InterceptRequests>
-            );
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception("ID", handler), {
-                wrapper: Wrapper,
-            });
-
-            // Act
-            const result = await interceptedHandler();
-
-            // Assert
-            expect(result).toBe("INTERCEPTED_DATA");
-        });
-
-        it("should not invoke interceptors or handlers beyond a non-null interception", () => {
-            // Arrange
-            const handler = jest
-                .fn()
-                .mockRejectedValue(
-                    new Error("This handler should have been intercepted"),
-                );
-            const interceptorFurthest = jest
-                .fn()
-                .mockRejectedValue(
-                    new Error("This interceptor should not get called"),
-                );
-            const interceptorNearest = jest
-                .fn()
-                .mockResolvedValue("INTERCEPTED_DATA");
-            const Wrapper = ({children}: any) => (
-                <InterceptRequests interceptor={interceptorFurthest}>
-                    <InterceptRequests interceptor={interceptorNearest}>
-                        {children}
-                    </InterceptRequests>
-                </InterceptRequests>
-            );
-            const {
-                result: {current: interceptedHandler},
-            } = renderHook(() => useRequestInterception("ID", handler), {
-                wrapper: Wrapper,
-            });
-
-            // Act
-            interceptedHandler();
-
-            // Assert
-            expect(handler).not.toHaveBeenCalled();
-            expect(interceptorFurthest).not.toHaveBeenCalled();
-        });
-    });
-});

package/src/hooks/__tests__/use-server-effect.test.ts

@@ -1,293 +0,0 @@
-import {renderHook as clientRenderHook} from "@testing-library/react-hooks";
-import {renderHookStatic} from "@khanacademy/wonder-blocks-testing-core";
-
-import {Server} from "@khanacademy/wonder-blocks-core";
-
-import TrackData from "../../components/track-data";
-import {RequestFulfillment} from "../../util/request-fulfillment";
-import {SsrCache} from "../../util/ssr-cache";
-import {RequestTracker} from "../../util/request-tracking";
-import {DataError} from "../../util/data-error";
-import * as UseRequestInterception from "../use-request-interception";
-
-import {useServerEffect} from "../use-server-effect";
-
-jest.mock("../use-request-interception");
-
-describe("#useServerEffect", () => {
-    beforeEach(() => {
-        jest.resetAllMocks();
-
-        const responseCache = new SsrCache();
-        jest.spyOn(SsrCache, "Default", "get").mockReturnValue(responseCache);
-        jest.spyOn(RequestFulfillment, "Default", "get").mockReturnValue(
-            new RequestFulfillment(),
-        );
-        jest.spyOn(RequestTracker, "Default", "get").mockReturnValue(
-            new RequestTracker(responseCache),
-        );
-
-        // Simple implementation of request interception that just returns
-        // the handler.
-        jest.spyOn(
-            UseRequestInterception,
-            "useRequestInterception",
-        ).mockImplementation((_: any, handler: any) => handler);
-    });
-
-    it("should call useRequestInterception", () => {
-        // Arrange
-        const useRequestInterceptSpy = jest
-            .spyOn(UseRequestInterception, "useRequestInterception")
-            .mockReturnValue(jest.fn());
-        const fakeHandler = jest.fn();
-
-        // Act
-        renderHookStatic(() => useServerEffect("ID", fakeHandler));
-
-        // Assert
-        expect(useRequestInterceptSpy).toHaveBeenCalledWith("ID", fakeHandler);
-    });
-
-    describe("when server-side", () => {
-        beforeEach(() => {
-            jest.spyOn(Server, "isServerSide").mockReturnValue(true);
-        });
-
-        it("should return null if no cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-
-            // Act
-            const {
-                result: {current: result},
-            } = renderHookStatic(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toBeNull();
-        });
-
-        it("should not directly request fulfillment", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            const fulfillRequestSpy = jest.spyOn(
-                RequestFulfillment.Default,
-                "fulfill",
-            );
-
-            // Act
-            renderHookStatic(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(fulfillRequestSpy).not.toHaveBeenCalled();
-        });
-
-        it("should track the intercepted request", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            const interceptedHandler = jest.fn();
-            jest.spyOn(
-                UseRequestInterception,
-                "useRequestInterception",
-            ).mockReturnValue(interceptedHandler);
-            const trackDataRequestSpy = jest.spyOn(
-                RequestTracker.Default,
-                "trackDataRequest",
-            );
-
-            // Act
-            renderHookStatic(() => useServerEffect("ID", fakeHandler), {
-                wrapper: TrackData,
-            });
-
-            // Assert
-            expect(trackDataRequestSpy).toHaveBeenCalledWith(
-                "ID",
-                interceptedHandler,
-                true,
-            );
-        });
-
-        it("should not track the intercepted request if skip is true", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            const interceptedHandler = jest.fn();
-            jest.spyOn(
-                UseRequestInterception,
-                "useRequestInterception",
-            ).mockReturnValue(interceptedHandler);
-            const trackDataRequestSpy = jest.spyOn(
-                RequestTracker.Default,
-                "trackDataRequest",
-            );
-
-            // Act
-            renderHookStatic(
-                () => useServerEffect("ID", fakeHandler, {skip: true}),
-                {
-                    wrapper: TrackData,
-                },
-            );
-
-            // Assert
-            expect(trackDataRequestSpy).not.toHaveBeenCalled();
-        });
-
-        it("should not track the intercepted request if there is a cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            const interceptedHandler = jest.fn();
-            jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
-                data: "DATA",
-                error: undefined,
-            });
-            jest.spyOn(
-                UseRequestInterception,
-                "useRequestInterception",
-            ).mockReturnValue(interceptedHandler);
-            const trackDataRequestSpy = jest.spyOn(
-                RequestTracker.Default,
-                "trackDataRequest",
-            );
-
-            // Act
-            renderHookStatic(() => useServerEffect("ID", fakeHandler), {
-                wrapper: TrackData,
-            });
-
-            // Assert
-            expect(trackDataRequestSpy).not.toHaveBeenCalled();
-        });
-
-        it("should return data cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
-                data: "DATA",
-                error: undefined,
-            });
-
-            // Act
-            const {
-                result: {current: result},
-            } = renderHookStatic(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toEqual({status: "success", data: "DATA"});
-        });
-
-        it("should return error cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
-                error: "ERROR",
-            });
-
-            // Act
-            const {
-                result: {current: result},
-            } = renderHookStatic(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toEqual({
-                status: "error",
-                error: expect.any(DataError),
-            });
-        });
-    });
-
-    describe("when client-side", () => {
-        beforeEach(() => {
-            jest.spyOn(Server, "isServerSide").mockReturnValue(false);
-        });
-
-        it("should return null if no cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-
-            // Act
-            const {
-                result: {current: result},
-            } = clientRenderHook(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toBeNull();
-        });
-
-        it("should return data cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
-                data: "DATA",
-                error: undefined,
-            });
-
-            // Act
-            const {
-                result: {current: result},
-            } = clientRenderHook(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toEqual({status: "success", data: "DATA"});
-        });
-
-        it("should return error cached result", () => {
-            // Arrange
-            const fakeHandler = jest.fn();
-            jest.spyOn(SsrCache.Default, "getEntry").mockReturnValueOnce({
-                error: "ERROR",
-            });
-
-            // Act
-            const {
-                result: {current: result},
-            } = clientRenderHook(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(result).toEqual({
-                status: "error",
-                error: expect.any(DataError),
-            });
-        });
-
-        it("should not track the request", () => {
-            // Arrange
-            const fakeHandler = jest.fn().mockReturnValue(
-                new Promise(() => {
-                    /*prevent act() warning*/
-                }),
-            );
-            const trackDataRequestSpy = jest.spyOn(
-                RequestTracker.Default,
-                "trackDataRequest",
-            );
-
-            // Act
-            clientRenderHook(() => useServerEffect("ID", fakeHandler), {
-                wrapper: TrackData,
-            });
-
-            // Assert
-            expect(trackDataRequestSpy).not.toHaveBeenCalled();
-        });
-
-        it("should not request fulfillment", () => {
-            // Arrange
-            const fakeHandler = jest.fn().mockReturnValue(
-                new Promise(() => {
-                    /*prevent act() warning*/
-                }),
-            );
-            const fulfillRequestSpy = jest.spyOn(
-                RequestFulfillment.Default,
-                "fulfill",
-            );
-
-            // Act
-            clientRenderHook(() => useServerEffect("ID", fakeHandler));
-
-            // Assert
-            expect(fulfillRequestSpy).not.toHaveBeenCalled();
-        });
-    });
-});