@khanacademy/wonder-blocks-data 2.3.4 → 3.1.1

package/src/components/__tests__/data.test.js

@@ -1,7 +1,7 @@
 /* eslint-disable max-lines */
 // @flow
 import * as React from "react";
-import {mount, shallow} from "enzyme";
+import {render, act} from "@testing-library/react";
 
 // eslint-disable-next-line import/extensions
 import * as ReactDOMServer from "react-dom/server";
@@ -11,7 +11,6 @@ import TrackData from "../track-data.js";
 import {RequestFulfillment} from "../../util/request-fulfillment.js";
 import {ResponseCache} from "../../util/response-cache.js";
 import {RequestTracker} from "../../util/request-tracking.js";
-import InterceptCache from "../intercept-cache.js";
 import InterceptData from "../intercept-data.js";
 import Data from "../data.js";
 
@@ -43,12 +42,13 @@ describe("Data", () => {
         describe("without cached data", () => {
             beforeEach(() => {
                 /**
-                 * Each of these test cases will never have cached data
-                 * retrieved.
+                 * Each of these test cases will not have cached data to be
+                 * retrieved in the beginning.
                  */
-                jest.spyOn(ResponseCache.Default, "getEntry").mockReturnValue(
-                    null,
-                );
+                jest.spyOn(
+                    ResponseCache.Default,
+                    "getEntry",
+                ).mockReturnValueOnce(null);
             });
 
             it("should make request for data on construction", () => {
@@ -59,15 +59,13 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
@@ -83,26 +81,22 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
                 );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        loading: true,
-                    }),
-                );
+                expect(fakeChildrenFn).toHaveBeenCalledWith({
+                    status: "loading",
+                });
             });
 
             it("should share single request across all uses", () => {
@@ -113,15 +107,13 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                render(
                     <View>
                         <Data handler={fakeHandler} options={"options"}>
                             {fakeChildrenFn}
@@ -137,7 +129,7 @@ describe("Data", () => {
                 expect(fulfillRequestSpy).toHaveBeenCalledTimes(1);
             });
 
-            it("should render with an error if the request resolves to an error", async () => {
+            it("should render with an error if the request rejects to an error", async () => {
                 // Arrange
                 const fulfillSpy = jest.spyOn(
                     RequestFulfillment.Default,
@@ -147,15 +139,13 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.reject(new Error("OH NOES!")),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
@@ -163,12 +153,12 @@ describe("Data", () => {
                 /**
                  * We wait for the fulfillment to resolve.
                  */
-                await fulfillSpy.mock.results[0].value;
+                await act(() => fulfillSpy.mock.results[0].value);
 
                 // Assert
                 expect(fakeChildrenFn).toHaveBeenCalledTimes(2);
                 expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: false,
+                    status: "error",
                     error: "OH NOES!",
                 });
             });
@@ -183,15 +173,13 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("YAY! DATA!"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
@@ -199,12 +187,12 @@ describe("Data", () => {
                 /**
                  * We wait for the fulfillment to resolve.
                  */
-                await fulfillSpy.mock.results[0].value;
+                await act(() => fulfillSpy.mock.results[0].value);
 
                 // Assert
                 expect(fakeChildrenFn).toHaveBeenCalledTimes(2);
                 expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: false,
+                    status: "success",
                     data: "YAY! DATA!",
                 });
             });
@@ -218,9 +206,7 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("YAY!"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
@@ -231,7 +217,7 @@ describe("Data", () => {
                     });
 
                 // Act
-                mount(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
@@ -239,12 +225,14 @@ describe("Data", () => {
                 /**
                  * We wait for the fulfillment to reject.
                  */
-                await fulfillSpy.mock.results[0].value.catch(() => {});
+                await act(() =>
+                    fulfillSpy.mock.results[0].value.catch(() => {}),
+                );
 
                 // Assert
                 expect(fakeChildrenFn).toHaveBeenCalledTimes(2);
                 expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: false,
+                    status: "error",
                     error: "CATASTROPHE!",
                 });
                 expect(consoleSpy).toHaveBeenCalledWith(
@@ -252,50 +240,53 @@ describe("Data", () => {
                 );
             });
 
-            it("should start loading if the handler changes and request not cached", async () => {
+            it("should render loading if the handler changes and request not cached", async () => {
                 // Arrange
                 const fulfillSpy = jest.spyOn(
                     RequestFulfillment.Default,
                     "fulfill",
                 );
-
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.reject(new Error("OH NOES!")),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "TYPE1",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeHandler2: IRequestHandler<string, string> = {
-                    fulfillRequest: () => new Promise(() => {}),
+                    fulfillRequest: () =>
+                        new Promise(() => {
+                            /*pending*/
+                        }),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "TYPE2",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
-                const wrapper = mount(
+                const wrapper = render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
                 );
-                // Make sure we render as laoded.
-                await fulfillSpy.mock.results[0].value;
+                // We want to make sure we render the error state so we can
+                // see our switch back to loading.
+                await act(() => fulfillSpy.mock.results[0].value);
                 // Clear out calls so everything is from the props change.
                 fulfillSpy.mockClear();
                 fakeChildrenFn.mockClear();
 
                 // Act
-                wrapper.setProps({
-                    handler: fakeHandler2,
-                });
+                wrapper.rerender(
+                    <Data handler={fakeHandler2} options={"options"}>
+                        {fakeChildrenFn}
+                    </Data>,
+                );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledTimes(1);
+                // Render 1: Caused by handler changed
+                // Render 2: Caused by result state changing to null
+                expect(fakeChildrenFn).toHaveBeenCalledTimes(2);
                 expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: true,
+                    status: "loading",
                 });
             });
 
@@ -309,134 +300,34 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("HELLO!"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
-                const wrapper = mount(
+                const wrapper = render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
                 );
-                await fulfillSpy.mock.results[0].value;
+                // We want to make sure we render the data state so we can
+                // see our switch back to loading.
+                await act(() => fulfillSpy.mock.results[0].value);
                 fulfillSpy.mockClear();
                 fakeChildrenFn.mockClear();
 
                 // Act
-                wrapper.setProps({
-                    options: "new-options",
-                });
+                wrapper.rerender(
+                    <Data handler={fakeHandler} options={"new-options"}>
+                        {fakeChildrenFn}
+                    </Data>,
+                );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledTimes(1);
+                // Render 1: Caused by handler changed
+                // Render 2: Caused by result state changing to null
+                expect(fakeChildrenFn).toHaveBeenCalledTimes(2);
                 expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: true,
-                });
-            });
-
-            describe("with cache interceptor", () => {
-                it("should call the interceptor with null", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    mount(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeGetEntryFn).toHaveBeenCalledWith(
-                        "options",
-                        null,
-                    );
-                });
-
-                it("should defer to the handler if interceptor returns null", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    mount(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fulfillRequestSpy).toHaveBeenCalledWith("options");
-                });
-
-                it("should render with the intercepted cache entry", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        error: "BOOMY BOOM!",
-                    }));
-
-                    // Act
-                    mount(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        error: "BOOMY BOOM!",
-                    });
-                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
+                    status: "loading",
                 });
             });
 
@@ -449,9 +340,7 @@ describe("Data", () => {
                     const fakeHandler: IRequestHandler<string, string> = {
                         fulfillRequest: fulfillRequestSpy,
                         getKey: (o) => o,
-                        shouldRefreshCache: () => false,
                         type: "MY_HANDLER",
-                        cache: null,
                         hydrate: true,
                     };
                     const fakeChildrenFn = jest.fn(() => null);
@@ -460,7 +349,7 @@ describe("Data", () => {
                     );
 
                     // Act
-                    mount(
+                    render(
                         <InterceptData
                             handler={fakeHandler}
                             fulfillRequest={fulfillRequestFn}
@@ -485,16 +374,14 @@ describe("Data", () => {
                     const fakeHandler: IRequestHandler<string, string> = {
                         fulfillRequest: fulfillRequestSpy,
                         getKey: (o) => o,
-                        shouldRefreshCache: () => false,
                         type: "MY_HANDLER",
-                        cache: null,
                         hydrate: true,
                     };
                     const fakeChildrenFn = jest.fn(() => null);
                     const fulfillRequestFn = jest.fn(() => null);
 
                     // Act
-                    mount(
+                    render(
                         <InterceptData
                             handler={fakeHandler}
                             fulfillRequest={fulfillRequestFn}
@@ -524,69 +411,82 @@ describe("Data", () => {
                 });
             });
 
-            it("should not request data on construction", () => {
+            it("should render first time with the cached data", () => {
                 // Arrange
-                const fulfillRequestSpy = jest.fn();
                 const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: fulfillRequestSpy,
+                    fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                shallow(
+                render(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
                 );
 
                 // Assert
-                expect(fulfillRequestSpy).not.toHaveBeenCalled();
+                expect(fakeChildrenFn).toHaveBeenCalledWith({
+                    status: "success",
+                    data: "YAY! DATA!",
+                });
+            });
+        });
+    });
+
+    describe("SSR: isServerSide true", () => {
+        beforeEach(() => {
+            jest.spyOn(Server, "isServerSide").mockReturnValue(true);
+        });
+
+        describe("without cached data", () => {
+            beforeEach(() => {
+                /**
+                 * Each of these test cases will never have cached data
+                 * retrieved.
+                 */
+                jest.spyOn(ResponseCache.Default, "getEntry").mockReturnValue(
+                    null,
+                );
             });
 
-            it("should request data if shouldRefreshCache returns true", () => {
+            it("should not request data", () => {
                 // Arrange
                 const fulfillRequestSpy = jest.fn().mockResolvedValue("data");
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: (o) => o,
-                    shouldRefreshCache: () => true,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                ReactDOMServer.renderToString(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
                 );
 
                 // Assert
-                expect(fulfillRequestSpy).toHaveBeenCalledWith("options");
-                expect(fulfillRequestSpy).toHaveBeenCalledTimes(1);
+                expect(fulfillRequestSpy).not.toHaveBeenCalled();
             });
 
-            it("should render first time with the cached data", () => {
+            it("should render children with loading", () => {
                 // Arrange
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
 
                 // Act
-                mount(
+                ReactDOMServer.renderToString(
                     <Data handler={fakeHandler} options={"options"}>
                         {fakeChildrenFn}
                     </Data>,
@@ -594,676 +494,120 @@ describe("Data", () => {
 
                 // Assert
                 expect(fakeChildrenFn).toHaveBeenCalledWith({
-                    loading: false,
-                    data: "YAY! DATA!",
+                    status: "loading",
                 });
             });
 
-            it("should render with new data if the handler changes and request cached", () => {
+            it("should invoke the tracking call", () => {
                 // Arrange
-                const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: () => Promise.reject(new Error("OH NOES!")),
-                    getKey: (o) => o,
-                    shouldRefreshCache: () => false,
-                    type: "TYPE1",
-                    cache: null,
-                    hydrate: true,
-                };
-                const fakeHandler2: IRequestHandler<string, string> = {
-                    fulfillRequest: () => new Promise(() => {}),
-                    getKey: (o) => o,
-                    shouldRefreshCache: () => false,
-                    type: "TYPE2",
-                    cache: null,
-                    hydrate: true,
-                };
-                const fakeChildrenFn = jest.fn(() => null);
-                const wrapper = mount(
-                    <Data handler={fakeHandler} options={"options"}>
-                        {fakeChildrenFn}
-                    </Data>,
+                const trackSpy = jest.spyOn(
+                    RequestTracker.Default,
+                    "trackDataRequest",
                 );
-                // Clear out calls so everything is from the props change.
-                fakeChildrenFn.mockClear();
-                jest.spyOn(ResponseCache.Default, "getEntry").mockReturnValue({
-                    data: "NEW DATA!",
-                });
-
-                // Act
-                wrapper.setProps({
-                    handler: fakeHandler2,
-                });
-
-                // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledTimes(1);
-                expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: false,
-                    data: "NEW DATA!",
-                });
-            });
-
-            it("should render with new data if the options key changes and is cached", () => {
-                // Arrange
                 const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: () => Promise.resolve("Not called!"),
+                    fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
-                const wrapper = mount(
-                    <Data handler={fakeHandler} options={"options"}>
-                        {fakeChildrenFn}
-                    </Data>,
-                );
-                fakeChildrenFn.mockClear();
-                jest.spyOn(ResponseCache.Default, "getEntry").mockReturnValue({
-                    data: "NEW DATA!",
-                });
 
                 // Act
-                wrapper.setProps({
-                    options: "new-options",
-                });
+                ReactDOMServer.renderToString(
+                    <TrackData>
+                        <Data handler={fakeHandler} options={"options"}>
+                            {fakeChildrenFn}
+                        </Data>
+                    </TrackData>,
+                );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledTimes(1);
-                expect(fakeChildrenFn).toHaveBeenLastCalledWith({
-                    loading: false,
-                    data: "NEW DATA!",
-                });
+                expect(trackSpy).toHaveBeenCalledWith(fakeHandler, "options");
             });
 
-            describe("with cache interceptor", () => {
-                it("should call the interceptor with current cache entry", () => {
+            describe("with data interceptor", () => {
+                it("should not request data from the interceptor", () => {
                     // Arrange
+                    const fulfillRequestSpy = jest
+                        .fn()
+                        .mockResolvedValue("data");
                     const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
+                        fulfillRequest: fulfillRequestSpy,
                         getKey: (o) => o,
-                        shouldRefreshCache: () => false,
                         type: "MY_HANDLER",
-                        cache: null,
                         hydrate: true,
                     };
                     const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    mount(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
+                    const fulfillRequestFn = jest.fn(() =>
+                        Promise.resolve("DATA!"),
                     );
 
-                    // Assert
-                    expect(fakeGetEntryFn).toHaveBeenCalledWith("options", {
-                        data: "YAY! DATA!",
-                    });
-                });
-
-                it("should defer to the main cache if interceptor returns null", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
                     // Act
-                    mount(
-                        <InterceptCache
+                    ReactDOMServer.renderToString(
+                        <InterceptData
                             handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
+                            fulfillRequest={fulfillRequestFn}
                         >
                             <Data handler={fakeHandler} options={"options"}>
                                 {fakeChildrenFn}
                             </Data>
-                        </InterceptCache>,
+                        </InterceptData>,
                     );
 
                     // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        data: "YAY! DATA!",
-                    });
+                    expect(fulfillRequestFn).not.toHaveBeenCalled();
+                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
                 });
 
-                it("should render with the intercepted cache entry", () => {
+                it("should invoke the tracking call", () => {
                     // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
+                    const trackSpy = jest.spyOn(
+                        RequestTracker.Default,
+                        "trackDataRequest",
+                    );
+                    const fakeHandler = {
                         fulfillRequest: () => Promise.resolve("data"),
                         getKey: (o) => o,
-                        shouldRefreshCache: () => false,
                         type: "MY_HANDLER",
-                        cache: null,
                         hydrate: true,
                     };
                     const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        error: "BOOMY BOOM!",
-                    }));
+                    const fulfillRequestFn = jest.fn(() =>
+                        Promise.resolve("DATA!"),
+                    );
 
                     // Act
-                    mount(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
+                    ReactDOMServer.renderToString(
+                        <TrackData>
+                            <InterceptData
+                                handler={
+                                    (fakeHandler: IRequestHandler<
+                                        string,
+                                        string,
+                                    >)
+                                }
+                                fulfillRequest={fulfillRequestFn}
+                            >
+                                <Data handler={fakeHandler} options={"options"}>
+                                    {fakeChildrenFn}
+                                </Data>
+                            </InterceptData>
+                        </TrackData>,
                     );
 
                     // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        error: "BOOMY BOOM!",
-                    });
+                    expect(trackSpy).toHaveBeenCalledWith(
+                        {
+                            fulfillRequest: expect.any(Function),
+                            getKey: expect.any(Function),
+                            type: "MY_HANDLER",
+                            hydrate: true,
+                        },
+                        "options",
+                    );
                 });
             });
-
-            describe("with data interceptor", () => {
-                it("should request data from handler if interceptor shouldRefreshCache returns true", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const shouldRefreshCacheSpy = jest.fn(() => false);
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: shouldRefreshCacheSpy,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const shouldRefreshCacheFn = jest.fn(() => true);
-
-                    // Act
-                    mount(
-                        <InterceptData
-                            handler={fakeHandler}
-                            shouldRefreshCache={shouldRefreshCacheFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptData>,
-                    );
-
-                    // Assert
-                    expect(fulfillRequestSpy).toHaveBeenCalledWith("options");
-                    expect(fulfillRequestSpy).toHaveBeenCalledTimes(1);
-                    expect(shouldRefreshCacheSpy).not.toHaveBeenCalled();
-                });
-
-                it("should defer to handler if interceptor shouldRefreshCache returns null", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const shouldRefreshCacheSpy = jest.fn(() => false);
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: shouldRefreshCacheSpy,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const shouldRefreshCacheFn = jest.fn(() => null);
-
-                    // Act
-                    mount(
-                        <InterceptData
-                            handler={fakeHandler}
-                            shouldRefreshCache={shouldRefreshCacheFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptData>,
-                    );
-
-                    // Assert
-                    expect(shouldRefreshCacheSpy).toHaveBeenCalledWith(
-                        "options",
-                        expect.any(Object),
-                    );
-                });
-
-                it("should request data from interceptor if handler shouldRefreshCache returns true", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => true,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fulfillRequestFn = jest.fn(() =>
-                        Promise.resolve("DATA!"),
-                    );
-
-                    // Act
-                    mount(
-                        <InterceptData
-                            handler={fakeHandler}
-                            fulfillRequest={fulfillRequestFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptData>,
-                    );
-
-                    // Assert
-                    expect(fulfillRequestFn).toHaveBeenCalledWith("options");
-                    expect(fulfillRequestFn).toHaveBeenCalledTimes(1);
-                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
-                });
-
-                it("should request data from interceptor if interceptor shouldRefreshCache returns true", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const shouldRefreshCacheFn = jest.fn(() => true);
-                    const fulfillRequestFn = jest.fn(() =>
-                        Promise.resolve("DATA!"),
-                    );
-
-                    // Act
-                    mount(
-                        <InterceptData
-                            handler={fakeHandler}
-                            fulfillRequest={fulfillRequestFn}
-                            shouldRefreshCache={shouldRefreshCacheFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptData>,
-                    );
-
-                    // Assert
-                    expect(fulfillRequestFn).toHaveBeenCalledWith("options");
-                    expect(fulfillRequestFn).toHaveBeenCalledTimes(1);
-                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
-                });
-            });
-        });
-    });
-
-    describe("SSR: isServerSide true", () => {
-        beforeEach(() => {
-            jest.spyOn(Server, "isServerSide").mockReturnValue(true);
-        });
-
-        describe("without cached data", () => {
-            beforeEach(() => {
-                /**
-                 * Each of these test cases will never have cached data
-                 * retrieved.
-                 */
-                jest.spyOn(ResponseCache.Default, "getEntry").mockReturnValue(
-                    null,
-                );
-            });
-
-            it("should not request data", () => {
-                // Arrange
-                const fulfillRequestSpy = jest.fn().mockResolvedValue("data");
-                const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: fulfillRequestSpy,
-                    getKey: (o) => o,
-                    shouldRefreshCache: () => false,
-                    type: "MY_HANDLER",
-                    cache: null,
-                    hydrate: true,
-                };
-                const fakeChildrenFn = jest.fn(() => null);
-
-                // Act
-                ReactDOMServer.renderToString(
-                    <Data handler={fakeHandler} options={"options"}>
-                        {fakeChildrenFn}
-                    </Data>,
-                );
-
-                // Assert
-                expect(fulfillRequestSpy).not.toHaveBeenCalled();
-            });
-
-            it("should render children with loading", () => {
-                // Arrange
-                const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: () => Promise.resolve("data"),
-                    getKey: (o) => o,
-                    shouldRefreshCache: () => false,
-                    type: "MY_HANDLER",
-                    cache: null,
-                    hydrate: true,
-                };
-                const fakeChildrenFn = jest.fn(() => null);
-
-                // Act
-                ReactDOMServer.renderToString(
-                    <Data handler={fakeHandler} options={"options"}>
-                        {fakeChildrenFn}
-                    </Data>,
-                );
-
-                // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        loading: true,
-                    }),
-                );
-            });
-
-            it("should invoke the tracking call", () => {
-                // Arrange
-                const trackSpy = jest.spyOn(
-                    RequestTracker.Default,
-                    "trackDataRequest",
-                );
-                const fakeHandler: IRequestHandler<string, string> = {
-                    fulfillRequest: () => Promise.resolve("data"),
-                    getKey: (o) => o,
-                    shouldRefreshCache: () => false,
-                    type: "MY_HANDLER",
-                    cache: null,
-                    hydrate: true,
-                };
-                const fakeChildrenFn = jest.fn(() => null);
-
-                // Act
-                ReactDOMServer.renderToString(
-                    <TrackData>
-                        <Data handler={fakeHandler} options={"options"}>
-                            {fakeChildrenFn}
-                        </Data>
-                    </TrackData>,
-                );
-
-                // Assert
-                expect(trackSpy).toHaveBeenCalledWith(fakeHandler, "options");
-            });
-
-            describe("with cache interceptor", () => {
-                it("should call the interceptor with null", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeGetEntryFn).toHaveBeenCalledWith(
-                        "options",
-                        null,
-                    );
-                });
-
-                it("should render with the intercepted cache entry", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        error: "BOOMY BOOM!",
-                    }));
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        error: "BOOMY BOOM!",
-                    });
-                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
-                });
-
-                it("should not invoke the tracking call", () => {
-                    // Arrange
-                    const trackSpy = jest.spyOn(
-                        RequestTracker.Default,
-                        "trackDataRequest",
-                    );
-                    const fakeHandler = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        data: "BOOMY BOOM!",
-                    }));
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <TrackData>
-                            <InterceptCache
-                                handler={fakeHandler}
-                                getEntry={fakeGetEntryFn}
-                            >
-                                <Data handler={fakeHandler} options={"options"}>
-                                    {fakeChildrenFn}
-                                </Data>
-                            </InterceptCache>
-                        </TrackData>,
-                    );
-
-                    // Assert
-                    expect(trackSpy).not.toHaveBeenCalled();
-                });
-            });
-
-            describe("with data interceptor", () => {
-                it("should not request data from the interceptor", () => {
-                    // Arrange
-                    const fulfillRequestSpy = jest
-                        .fn()
-                        .mockResolvedValue("data");
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: fulfillRequestSpy,
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fulfillRequestFn = jest.fn(() =>
-                        Promise.resolve("DATA!"),
-                    );
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptData
-                            handler={fakeHandler}
-                            fulfillRequest={fulfillRequestFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptData>,
-                    );
-
-                    // Assert
-                    expect(fulfillRequestFn).not.toHaveBeenCalled();
-                    expect(fulfillRequestSpy).not.toHaveBeenCalled();
-                });
-
-                it("should invoke the tracking call", () => {
-                    // Arrange
-                    const trackSpy = jest.spyOn(
-                        RequestTracker.Default,
-                        "trackDataRequest",
-                    );
-                    const fakeHandler = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const shouldRefreshCacheFn = jest.fn(() => true);
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <TrackData>
-                            <InterceptData
-                                handler={
-                                    (fakeHandler: IRequestHandler<
-                                        string,
-                                        string,
-                                    >)
-                                }
-                                shouldRefreshCache={shouldRefreshCacheFn}
-                            >
-                                <Data handler={fakeHandler} options={"options"}>
-                                    {fakeChildrenFn}
-                                </Data>
-                            </InterceptData>
-                        </TrackData>,
-                    );
-
-                    // Assert
-                    expect(trackSpy).toHaveBeenCalledWith(
-                        {
-                            fulfillRequest: expect.any(Function),
-                            getKey: expect.any(Function),
-                            type: "MY_HANDLER",
-                            cache: null,
-                            hydrate: true,
-                            shouldRefreshCache: expect.any(Function),
-                        },
-                        "options",
-                    );
-                });
-
-                it("should invoke tracking call with handler that defers to interceptor", () => {
-                    // Arrange
-                    const trackSpy = jest.spyOn(
-                        RequestTracker.Default,
-                        "trackDataRequest",
-                    );
-                    const fakeHandler = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const shouldRefreshCacheFn = jest.fn(() => true);
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <TrackData>
-                            <InterceptData
-                                handler={
-                                    (fakeHandler: IRequestHandler<
-                                        string,
-                                        string,
-                                    >)
-                                }
-                                shouldRefreshCache={shouldRefreshCacheFn}
-                            >
-                                <Data handler={fakeHandler} options={"options"}>
-                                    {fakeChildrenFn}
-                                </Data>
-                            </InterceptData>
-                        </TrackData>,
-                    );
-                    trackSpy.mock.calls[0][0].shouldRefreshCache(
-                        "options",
-                        null,
-                    );
-
-                    // Assert
-                    expect(shouldRefreshCacheFn).toHaveBeenCalledWith(
-                        "options",
-                        null,
-                    );
-                    expect(shouldRefreshCacheFn).toHaveBeenCalledTimes(1);
-                });
-            });
-        });
+        });
 
         describe("with cached data", () => {
             beforeEach(() => {
@@ -1282,9 +626,7 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
@@ -1305,9 +647,7 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
@@ -1320,12 +660,10 @@ describe("Data", () => {
                 );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        loading: false,
-                        data: "YAY! DATA!",
-                    }),
-                );
+                expect(fakeChildrenFn).toHaveBeenCalledWith({
+                    status: "success",
+                    data: "YAY! DATA!",
+                });
             });
 
             it("should render children with error", () => {
@@ -1336,9 +674,7 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
@@ -1351,12 +687,10 @@ describe("Data", () => {
                 );
 
                 // Assert
-                expect(fakeChildrenFn).toHaveBeenCalledWith(
-                    expect.objectContaining({
-                        loading: false,
-                        error: "OH NO! IT GO BOOM",
-                    }),
-                );
+                expect(fakeChildrenFn).toHaveBeenCalledWith({
+                    status: "error",
+                    error: "OH NO! IT GO BOOM",
+                });
             });
 
             it("should not invoke the tracking call", () => {
@@ -1368,9 +702,7 @@ describe("Data", () => {
                 const fakeHandler: IRequestHandler<string, string> = {
                     fulfillRequest: () => Promise.resolve("data"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "MY_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeChildrenFn = jest.fn(() => null);
@@ -1391,142 +723,6 @@ describe("Data", () => {
                 );
             });
 
-            describe("with cache interceptor", () => {
-                it("should call the interceptor with current cache entry", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeGetEntryFn).toHaveBeenCalledWith("options", {
-                        data: "YAY! DATA!",
-                    });
-                });
-
-                it("should defer to the main cache if interceptor returns null", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => null);
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        data: "YAY! DATA!",
-                    });
-                });
-
-                it("should render with the intercepted cache entry", () => {
-                    // Arrange
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        error: "BOOMY BOOM!",
-                    }));
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <InterceptCache
-                            handler={fakeHandler}
-                            getEntry={fakeGetEntryFn}
-                        >
-                            <Data handler={fakeHandler} options={"options"}>
-                                {fakeChildrenFn}
-                            </Data>
-                        </InterceptCache>,
-                    );
-
-                    // Assert
-                    expect(fakeChildrenFn).toHaveBeenCalledWith({
-                        loading: false,
-                        error: "BOOMY BOOM!",
-                    });
-                });
-
-                it("should not invoke the tracking call", () => {
-                    // Arrange
-                    const trackSpy = jest.spyOn(
-                        RequestTracker.Default,
-                        "trackDataRequest",
-                    );
-                    const fakeHandler: IRequestHandler<string, string> = {
-                        fulfillRequest: () => Promise.resolve("data"),
-                        getKey: (o) => o,
-                        shouldRefreshCache: () => false,
-                        type: "MY_HANDLER",
-                        cache: null,
-                        hydrate: true,
-                    };
-                    const fakeChildrenFn = jest.fn(() => null);
-                    const fakeGetEntryFn = jest.fn(() => ({
-                        data: "DATA!",
-                    }));
-
-                    // Act
-                    ReactDOMServer.renderToString(
-                        <TrackData>
-                            <InterceptCache
-                                handler={fakeHandler}
-                                getEntry={fakeGetEntryFn}
-                            >
-                                <Data handler={fakeHandler} options={"options"}>
-                                    {fakeChildrenFn}
-                                </Data>
-                            </InterceptCache>
-                        </TrackData>,
-                    );
-
-                    // Assert
-                    expect(trackSpy).not.toHaveBeenCalled();
-                });
-            });
-
             describe("with data interceptor", () => {
                 it("should not request data from interceptor", () => {
                     // Arrange
@@ -1536,9 +732,7 @@ describe("Data", () => {
                     const fakeHandler: IRequestHandler<string, string> = {
                         fulfillRequest: fulfillRequestSpy,
                         getKey: (o) => o,
-                        shouldRefreshCache: jest.fn(() => true),
                         type: "MY_HANDLER",
-                        cache: null,
                         hydrate: true,
                     };
                     const fakeChildrenFn = jest.fn(() => null);