@khanacademy/wonder-blocks-data 2.3.4 → 3.1.1

package/src/util/__tests__/memory-cache.test.js

@@ -47,9 +47,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -71,9 +69,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -95,9 +91,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -119,9 +113,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -142,9 +134,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -165,9 +155,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -186,9 +174,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -207,9 +193,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -230,9 +214,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -253,9 +235,7 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
@@ -269,6 +249,23 @@ describe("MemoryCache", () => {
     });
 
     describe("#removeAll", () => {
+        it("should return 0 if the handler subcache is absent", () => {
+            // Arrange
+            const cache = new MemoryCache();
+            const fakeHandler: IRequestHandler<string, string> = {
+                getKey: () => "MY_KEY",
+                type: "MY_HANDLER",
+                fulfillRequest: jest.fn(),
+                hydrate: true,
+            };
+
+            // Act
+            const result = cache.removeAll(fakeHandler);
+
+            // Assert
+            expect(result).toBe(0);
+        });
+
         it("should remove matching entries from handler subcache", () => {
             const cache = new MemoryCache({
                 MY_HANDLER: {
@@ -283,32 +280,84 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
+                hydrate: true,
+            };
+
+            // Act
+            cache.removeAll(fakeHandler, (k, d) => d.data === "2");
+            const result = cache.cloneData();
+
+            // Assert
+            expect(result).toStrictEqual({
+                MY_HANDLER: {
+                    MY_KEY2: {data: "1"},
+                },
+                OTHER_HANDLER: {
+                    MY_KEY: {data: "1"},
+                },
+            });
+        });
+
+        it("should return the number of items that matched the predicate and were removed", () => {
+            const cache = new MemoryCache({
+                MY_HANDLER: {
+                    MY_KEY: {data: "a"},
+                    MY_KEY2: {data: "b"},
+                    MY_KEY3: {data: "a"},
+                },
+                OTHER_HANDLER: {
+                    MY_KEY: {data: "b"},
+                },
+            });
+            const fakeHandler: IRequestHandler<string, string> = {
+                getKey: () => "MY_KEY",
+                type: "MY_HANDLER",
+                fulfillRequest: jest.fn(),
                 hydrate: true,
             };
 
             // Act
             const result = cache.removeAll(
                 fakeHandler,
-                (k, d) => d.data === "2",
+                (k, d) => d.data === "a",
             );
-            const after = cache.cloneData();
 
             // Assert
             expect(result).toBe(2);
-            expect(after).toStrictEqual({
+        });
+
+        it("should remove the entire handler subcache if no predicate", () => {
+            const cache = new MemoryCache({
                 MY_HANDLER: {
-                    MY_KEY2: {data: "1"},
+                    MY_KEY: {data: "data!"},
+                    MY_KEY2: {data: "data!"},
+                    MY_KEY3: {data: "data!"},
                 },
                 OTHER_HANDLER: {
-                    MY_KEY: {data: "1"},
+                    MY_KEY: {data: "data!"},
+                },
+            });
+            const fakeHandler: IRequestHandler<string, string> = {
+                getKey: () => "MY_KEY",
+                type: "MY_HANDLER",
+                fulfillRequest: jest.fn(),
+                hydrate: true,
+            };
+
+            // Act
+            cache.removeAll(fakeHandler);
+            const result = cache.cloneData();
+
+            // Assert
+            expect(result).toStrictEqual({
+                OTHER_HANDLER: {
+                    MY_KEY: {data: "data!"},
                 },
             });
         });
 
-        it("should remove all entries from handler subcache if no predicate", () => {
+        it("should return the number of items that were in the handler subcache if there was no predicate", () => {
             const cache = new MemoryCache({
                 MY_HANDLER: {
                     MY_KEY: {data: "data!"},
@@ -322,26 +371,76 @@ describe("MemoryCache", () => {
             const fakeHandler: IRequestHandler<string, string> = {
                 getKey: () => "MY_KEY",
                 type: "MY_HANDLER",
-                shouldRefreshCache: () => false,
                 fulfillRequest: jest.fn(),
-                cache: null,
                 hydrate: true,
             };
 
             // Act
             const result = cache.removeAll(fakeHandler);
-            const after = cache.cloneData();
 
             // Assert
             expect(result).toBe(3);
-            expect(after).toStrictEqual({
-                MY_HANDLER: {},
-                OTHER_HANDLER: {
+        });
+    });
+
+    describe("#cloneData", () => {
+        it("should return a copy of the cache data", () => {});
+
+        it("should throw if there is an error during cloning", () => {
+            // Arrange
+            const cache = new MemoryCache({
+                MY_HANDLER: {
                     MY_KEY: {data: "data!"},
                 },
             });
+            jest.spyOn(JSON, "stringify").mockImplementation(() => {
+                throw new Error("BANG!");
+            });
+
+            // Act
+            const act = () => cache.cloneData();
+
+            // Assert
+            expect(act).toThrowErrorMatchingInlineSnapshot(
+                `"An error occurred while trying to clone the cache: Error: BANG!"`,
+            );
         });
     });
 
-    describe("#cloneData", () => {});
+    describe("@inUse", () => {
+        it("should return true if the cache contains data", () => {
+            // Arrange
+            const cache = new MemoryCache({
+                MY_HANDLER: {
+                    MY_KEY: {data: "data!"},
+                },
+            });
+
+            // Act
+            const result = cache.inUse;
+
+            // Assert
+            expect(result).toBeTruthy();
+        });
+
+        it("should return false if the cache is empty", () => {
+            // Arrange
+            const cache = new MemoryCache({
+                MY_HANDLER: {
+                    MY_KEY: {data: "data!"},
+                },
+            });
+            cache.removeAll(
+                ({
+                    type: "MY_HANDLER",
+                }: any),
+            );
+
+            // Act
+            const result = cache.inUse;
+
+            // Assert
+            expect(result).toBeFalsy();
+        });
+    });
 });

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

@@ -17,32 +17,30 @@ describe("RequestFulfillment", () => {
     });
 
     describe("#fulfill", () => {
-        it("should cache errors caused directly by handlers", async () => {
+        it("should attempt to cache errors caused directly by handlers", async () => {
             // Arrange
             const responseCache = new ResponseCache();
             const requestFulfillment = new RequestFulfillment(responseCache);
+            const error = new Error("OH NO!");
             const fakeBadHandler: IRequestHandler<any, any> = {
                 fulfillRequest: () => {
-                    throw new Error("OH NO!");
+                    throw error;
                 },
                 getKey: jest.fn().mockReturnValue("MY_KEY"),
-                shouldRefreshCache: () => false,
                 type: "MY_TYPE",
-                cache: null,
                 hydrate: true,
             };
+            const cacheErrorSpy = jest.spyOn(responseCache, "cacheError");
 
             // Act
             await requestFulfillment.fulfill(fakeBadHandler, "OPTIONS");
 
             // Assert
-            expect(responseCache.cloneHydratableData()).toStrictEqual({
-                MY_TYPE: {
-                    MY_KEY: {
-                        error: "OH NO!",
-                    },
-                },
-            });
+            expect(cacheErrorSpy).toHaveBeenCalledWith(
+                fakeBadHandler,
+                "OPTIONS",
+                error,
+            );
         });
 
         it("should cache errors occurring in promises", async () => {
@@ -53,23 +51,20 @@ describe("RequestFulfillment", () => {
                 fulfillRequest: () =>
                     new Promise((resolve, reject) => reject("OH NO!")),
                 getKey: (o) => o,
-                shouldRefreshCache: () => false,
                 type: "BAD_REQUEST",
-                cache: null,
                 hydrate: true,
             };
+            const cacheErrorSpy = jest.spyOn(responseCache, "cacheError");
 
             // Act
             await requestFulfillment.fulfill(fakeBadRequestHandler, "OPTIONS");
 
             // Assert
-            expect(responseCache.cloneHydratableData()).toStrictEqual({
-                BAD_REQUEST: {
-                    OPTIONS: {
-                        error: "OH NO!",
-                    },
-                },
-            });
+            expect(cacheErrorSpy).toHaveBeenCalledWith(
+                fakeBadRequestHandler,
+                "OPTIONS",
+                "OH NO!",
+            );
         });
 
         it("should cache data from requests", async () => {
@@ -79,24 +74,20 @@ describe("RequestFulfillment", () => {
             const fakeRequestHandler: IRequestHandler<string, any> = {
                 fulfillRequest: () => Promise.resolve("DATA!"),
                 getKey: (o) => o,
-                shouldRefreshCache: () => false,
                 type: "VALID_REQUEST",
-                cache: null,
                 hydrate: true,
             };
+            const cacheDataSpy = jest.spyOn(responseCache, "cacheData");
 
             // Act
             await requestFulfillment.fulfill(fakeRequestHandler, "OPTIONS");
-            const result = responseCache.cloneHydratableData();
 
             // Assert
-            expect(result).toStrictEqual({
-                VALID_REQUEST: {
-                    OPTIONS: {
-                        data: "DATA!",
-                    },
-                },
-            });
+            expect(cacheDataSpy).toHaveBeenCalledWith(
+                fakeRequestHandler,
+                "OPTIONS",
+                "DATA!",
+            );
         });
 
         it("should return a promise of the result", async () => {
@@ -106,9 +97,7 @@ describe("RequestFulfillment", () => {
             const fakeRequestHandler: IRequestHandler<string, any> = {
                 fulfillRequest: () => Promise.resolve("DATA!"),
                 getKey: (o) => o,
-                shouldRefreshCache: () => false,
                 type: "VALID_REQUEST",
-                cache: null,
                 hydrate: true,
             };
 
@@ -131,9 +120,7 @@ describe("RequestFulfillment", () => {
             const fakeRequestHandler: IRequestHandler<string, any> = {
                 fulfillRequest: () => Promise.resolve("DATA!"),
                 getKey: (o) => o,
-                shouldRefreshCache: () => false,
                 type: "VALID_REQUEST",
-                cache: null,
                 hydrate: true,
             };
 
@@ -158,9 +145,7 @@ describe("RequestFulfillment", () => {
             const fakeRequestHandler: IRequestHandler<string, any> = {
                 fulfillRequest: () => Promise.resolve("DATA!"),
                 getKey: (o) => o,
-                shouldRefreshCache: () => false,
                 type: "VALID_REQUEST",
-                cache: null,
                 hydrate: false,
             };
 

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!"`,
+            );
         });
     });