@khanacademy/wonder-blocks-data 2.3.4 → 3.0.0

package/src/util/__tests__/request-handler.test.js

@@ -14,7 +14,7 @@ describe("../request-handler.js", () => {
         jest.restoreAllMocks();
     });
 
-    describe("#get type", () => {
+    describe("@type", () => {
         it("should return value passed in construction", () => {
             // Arrange
             const handler = new RequestHandler("MY_TYPE");
@@ -27,80 +27,80 @@ describe("../request-handler.js", () => {
         });
     });
 
-    describe("#getKey", () => {
-        it("should return a key for given options", () => {
+    describe("@hydrate", () => {
+        it("should return true when constructed with false", () => {
             // Arrange
-            const handler = new RequestHandler("MY_TYPE");
+            const handler = new RequestHandler("MY_TYPE", false);
 
             // Act
-            const result = handler.getKey({some: "options"});
+            const result = handler.hydrate;
 
             // Assert
-            expect(result).toMatchInlineSnapshot(
-                `"{\\"some\\":\\"options\\"}"`,
-            );
+            expect(result).toBeFalse();
         });
 
-        it("should return a key for undefined options", () => {
+        it("should return true when constructed with true", () => {
             // Arrange
-            const handler = new RequestHandler("MY_TYPE");
+            const handler = new RequestHandler("MY_TYPE", true);
 
             // Act
-            const result = handler.getKey(undefined);
+            const result = handler.hydrate;
 
             // Assert
-            expect(result).toMatchInlineSnapshot(`"undefined"`);
+            expect(result).toBeTrue();
         });
 
-        it("should throw if JSON.stringify fails", () => {
+        it("should return true by default", () => {
             // Arrange
             const handler = new RequestHandler("MY_TYPE");
-            jest.spyOn(JSON, "stringify").mockImplementation(() => {
-                throw new Error("OH NOES!");
-            });
 
             // Act
-            const underTest = () => handler.getKey({});
+            const result = handler.hydrate;
 
             // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"Failed to auto-generate key: Error: OH NOES!"`,
-            );
+            expect(result).toBeTrue();
         });
     });
 
-    describe("#shouldRefreshCache", () => {
-        it("should return true if no current cached entry", () => {
+    describe("#getKey", () => {
+        it("should return a key for given options", () => {
             // Arrange
             const handler = new RequestHandler("MY_TYPE");
 
             // Act
-            const result = handler.shouldRefreshCache({}, null);
+            const result = handler.getKey({some: "options"});
 
             // Assert
-            expect(result).toBeTruthy();
+            expect(result).toMatchInlineSnapshot(
+                `"{\\"some\\":\\"options\\"}"`,
+            );
         });
 
-        it("should return true if cached entry has error", () => {
+        it("should return a key for undefined options", () => {
             // Arrange
             const handler = new RequestHandler("MY_TYPE");
 
             // Act
-            const result = handler.shouldRefreshCache({}, {error: "oops!"});
+            const result = handler.getKey(undefined);
 
             // Assert
-            expect(result).toBeTruthy();
+            expect(result).toMatchInlineSnapshot(`"undefined"`);
         });
 
-        it("should return false if cached entry is data", () => {
+        it("should throw if JSON.stringify fails", () => {
             // Arrange
             const handler = new RequestHandler("MY_TYPE");
+            jest.spyOn(JSON, "stringify").mockImplementation(() => {
+                throw new Error("OH NOES!");
+            });
 
             // Act
-            const result = handler.shouldRefreshCache({}, {data: "yay! data"});
+            const underTest = () => handler.getKey({});
 
             // Assert
-            expect(result).toBeFalsy();
+            expect(underTest).toThrowErrorMatchingInlineSnapshot(
+                `"Failed to auto-generate key: Error: OH NOES!"`,
+            );
         });
     });
 

package/src/util/__tests__/request-tracking.test.js

@@ -1,7 +1,9 @@
 // @flow
 import * as React from "react";
 import {mount} from "enzyme";
+import "jest-enzyme";
 
+import {Server} from "@khanacademy/wonder-blocks-core";
 import {RequestTracker, TrackerContext} from "../request-tracking.js";
 import {ResponseCache} from "../response-cache.js";
 
@@ -27,6 +29,10 @@ describe("../request-tracking.js", () => {
     });
 
     describe("RequestTracker", () => {
+        beforeEach(() => {
+            jest.spyOn(Server, "isServerSide").mockReturnValue(true);
+        });
+
         const createRequestTracker = () =>
             /**
              * We pass our own response cache instance so that the test cases
@@ -34,6 +40,29 @@ describe("../request-tracking.js", () => {
              */
             new RequestTracker(new ResponseCache());
 
+        describe("@Default", () => {
+            it("should return an instance of RequestTracker", () => {
+                // Arrange
+
+                // Act
+                const result = RequestTracker.Default;
+
+                // Assert
+                expect(result).toBeInstanceOf(RequestTracker);
+            });
+
+            it("should return the same instance on each call", () => {
+                // Arrange
+
+                // Act
+                const result1 = RequestTracker.Default;
+                const result2 = RequestTracker.Default;
+
+                // Assert
+                expect(result1).toBe(result2);
+            });
+        });
+
         describe("#trackDataRequest", () => {
             it("should get the key for the request", () => {
                 // Arrange
@@ -42,9 +71,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: jest.fn(() => Promise.resolve(null)),
                     getKey: getKeySpy,
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 const options = {these: "are options"};
@@ -63,9 +90,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: jest.fn().mockReturnValue("MY_KEY"),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 const options = {these: "are options"};
@@ -86,9 +111,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: (options) => JSON.stringify(options),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 const options1 = {these: "are options"};
@@ -112,18 +135,14 @@ describe("../request-tracking.js", () => {
                 const fakeHandler1: IRequestHandler<any, any> = {
                     fulfillRequest: fulfillRequestSpy1,
                     getKey: jest.fn().mockReturnValue("MY_KEY1"),
-                    shouldRefreshCache: () => false,
                     type: handlerType,
-                    cache: null,
                     hydrate: true,
                 };
                 const fulfillRequestSpy2 = jest.fn();
                 const fakeHandler2: IRequestHandler<any, any> = {
                     fulfillRequest: fulfillRequestSpy2,
                     getKey: jest.fn().mockReturnValue("MY_KEY2"),
-                    shouldRefreshCache: () => false,
                     type: handlerType,
-                    cache: null,
                     hydrate: true,
                 };
                 const options1 = {these: "are options"};
@@ -160,9 +179,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: jest.fn(),
                     getKey: jest.fn().mockReturnValue("MY_KEY"),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 const options = {these: "are options"};
@@ -181,9 +198,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: jest.fn().mockResolvedValue(5),
                     getKey: jest.fn().mockReturnValue("MY_KEY"),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 const options = {these: "are options"};
@@ -218,9 +233,7 @@ describe("../request-tracking.js", () => {
                         throw new Error("OH NO!");
                     },
                     getKey: jest.fn().mockReturnValue("MY_KEY"),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(fakeBadHandler, "OPTIONS");
@@ -245,9 +258,7 @@ describe("../request-tracking.js", () => {
                     fulfillRequest: () =>
                         new Promise((resolve, reject) => reject("OH NO!")),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "BAD_REQUEST",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(
@@ -280,9 +291,7 @@ describe("../request-tracking.js", () => {
                     fulfillRequest: () =>
                         new Promise((resolve, reject) => reject("OH NO!")),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "BAD_REQUEST",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeBadHandler: IRequestHandler<string, any> = {
@@ -290,9 +299,7 @@ describe("../request-tracking.js", () => {
                         throw new Error("OH NO!");
                     },
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "BAD_HANDLER",
-                    cache: null,
                     hydrate: true,
                 };
                 const fakeValidHandler: IRequestHandler<string, any> = {
@@ -304,9 +311,7 @@ describe("../request-tracking.js", () => {
                         };
                     })(),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "VALID",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(
@@ -353,9 +358,7 @@ describe("../request-tracking.js", () => {
                 const fakeValidHandler: IRequestHandler<string, any> = {
                     fulfillRequest: () => Promise.resolve("DATA"),
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "VALID",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(fakeValidHandler, "OPTIONS1");
@@ -374,9 +377,7 @@ describe("../request-tracking.js", () => {
                 const fakeStaticHandler: IRequestHandler<string, any> = {
                     fulfillRequest: fakeFulfiller,
                     getKey: (o) => o,
-                    shouldRefreshCache: () => false,
                     type: "STATIC",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(fakeStaticHandler, "1");
@@ -401,9 +402,7 @@ describe("../request-tracking.js", () => {
                 const fakeHandler: IRequestHandler<any, any> = {
                     fulfillRequest: fulfillRequestSpy,
                     getKey: jest.fn().mockReturnValue("MY_KEY"),
-                    shouldRefreshCache: () => false,
                     type: "MY_TYPE",
-                    cache: null,
                     hydrate: true,
                 };
                 requestTracker.trackDataRequest(fakeHandler, "OPTIONS");