@khanacademy/wonder-blocks-data 5.0.1 → 6.0.0

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

@@ -78,7 +78,7 @@ describe("../request-tracking.js", () => {
             it("should track each matching request once", async () => {
                 // Arrange
                 const requestTracker = createRequestTracker();
-                const fakeHandler = jest.fn().mockResolvedValue(null);
+                const fakeHandler = jest.fn().mockResolvedValue("DATA");
 
                 // Act
                 requestTracker.trackDataRequest("ID", fakeHandler, true);
@@ -177,7 +177,7 @@ describe("../request-tracking.js", () => {
                 // Assert
                 expect(result).toStrictEqual({
                     ID: {
-                        error: "OH NO!",
+                        error: "Request failed",
                     },
                 });
             });
@@ -230,7 +230,7 @@ describe("../request-tracking.js", () => {
                 // Assert
                 expect(result).toStrictEqual({
                     BAD_REQUEST: {
-                        error: "OH NO!",
+                        error: "Request failed",
                     },
                     BAD_HANDLER: {
                         error: "OH NO!",
@@ -244,14 +244,33 @@ describe("../request-tracking.js", () => {
                 });
             });
 
-            it("should cope gracefully with null fulfillments", async () => {
+            it("should ignore loading results", async () => {
+                // Arrange
+                const requestTracker = createRequestTracker();
+                jest.spyOn(
+                    requestTracker._requestFulfillment,
+                    "fulfill",
+                ).mockResolvedValue({status: "loading"});
+                const fakeValidHandler = () =>
+                    Promise.reject(new Error("Not called for this test case"));
+                requestTracker.trackDataRequest("ID", fakeValidHandler, true);
+
+                // Act
+                const result = await requestTracker.fulfillTrackedRequests();
+
+                // Assert
+                expect(result).toStrictEqual({});
+            });
+
+            it("should ignore aborted results", async () => {
                 // Arrange
                 const requestTracker = createRequestTracker();
                 jest.spyOn(
                     requestTracker._requestFulfillment,
                     "fulfill",
-                ).mockReturnValue(null);
-                const fakeValidHandler = () => Promise.resolve("DATA");
+                ).mockResolvedValue({status: "aborted"});
+                const fakeValidHandler = () =>
+                    Promise.reject(new Error("Not called for this test case"));
                 requestTracker.trackDataRequest("ID", fakeValidHandler, false);
 
                 // Act
@@ -285,7 +304,7 @@ describe("../request-tracking.js", () => {
             it("should clear the tracked data requests", async () => {
                 // Arrange
                 const requestTracker = createRequestTracker();
-                const fakeHandler = jest.fn().mockResolvedValue(null);
+                const fakeHandler = jest.fn().mockResolvedValue("DATA");
                 requestTracker.trackDataRequest("ID", fakeHandler, true);
 
                 // Act

package/src/util/__tests__/result-from-cache-response.test.js

@@ -2,7 +2,7 @@
 import {resultFromCachedResponse} from "../result-from-cache-response.js";
 
 describe("#resultFromCachedResponse", () => {
-    it("should return loading status if cache entry is null", () => {
+    it("should return null cache entry is null", () => {
         // Arrange
         const cacheEntry = null;
 
@@ -10,9 +10,7 @@ describe("#resultFromCachedResponse", () => {
         const result = resultFromCachedResponse(cacheEntry);
 
         // Assert
-        expect(result).toStrictEqual({
-            status: "loading",
-        });
+        expect(result).toBeNull();
     });
 
     it("should return success status if cache entry has data", () => {
@@ -61,7 +59,23 @@ describe("#resultFromCachedResponse", () => {
         // Assert
         expect(result).toStrictEqual({
             status: "error",
-            error: "ERROR",
+            error: expect.any(Error),
         });
     });
+
+    it("should hydrate the error into an error object", () => {
+        // Arrange
+        const cacheEntry: any = {
+            data: null,
+            error: "ERROR",
+        };
+
+        // Act
+        // $FlowIgnore[incompatible-use]
+        // $FlowIgnore[prop-missing]
+        const {error} = resultFromCachedResponse(cacheEntry);
+
+        // Assert
+        expect(error).toMatchInlineSnapshot(`[HydratedDataError: ERROR]`);
+    });
 });

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

@@ -1,48 +1,7 @@
 // @flow
-import * as WSCore from "@khanacademy/wonder-stuff-core";
 import {ScopedInMemoryCache} from "../scoped-in-memory-cache.js";
 
 describe("ScopedInMemoryCache", () => {
-    describe("#constructor", () => {
-        it("should clone the passed source data", () => {
-            // Arrange
-            const sourceData = {
-                scope: {
-                    key: "value",
-                },
-            };
-
-            // Act
-            const cache = new ScopedInMemoryCache(sourceData);
-            // Try to mutate the cache.
-            sourceData["scope"] = {key: "SOME_NEW_DATA"};
-            const result = cache.get("scope", "key");
-
-            // Assert
-            expect(result).toStrictEqual("value");
-        });
-
-        it("should throw if the cloning fails", () => {
-            // Arrange
-            jest.spyOn(WSCore, "clone").mockImplementationOnce(() => {
-                throw new Error("BANG!");
-            });
-
-            // Act
-            const underTest = () =>
-                new ScopedInMemoryCache({
-                    scope: {
-                        BAD: "FOOD",
-                    },
-                });
-
-            // Assert
-            expect(underTest).toThrowErrorMatchingInlineSnapshot(
-                `"An error occurred trying to initialize from a response cache snapshot: Error: BANG!"`,
-            );
-        });
-    });
-
     describe("#set", () => {
         it.each`
             id
@@ -175,7 +134,7 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purge("scope1", "key2");
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({
@@ -202,7 +161,7 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purge("scope1", "key2");
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({
@@ -232,7 +191,7 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purgeScope("scope1", (id, value) => value === "a");
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({
@@ -262,7 +221,7 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purgeScope("scope1");
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({
@@ -299,7 +258,7 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purgeAll((scope, id, value) => value === "2");
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({
@@ -316,51 +275,13 @@ describe("ScopedInMemoryCache", () => {
 
             // Act
             cache.purgeAll();
-            const result = cache.clone();
+            const result = cache._cache;
 
             // Assert
             expect(result).toStrictEqual({});
         });
     });
 
-    describe("#clone", () => {
-        it("should return a copy of the cache data", () => {
-            // Arrange
-            const data = {
-                scope1: {key: "2"},
-                scope2: {key: "1"},
-                scope3: {key: "2"},
-            };
-            const cache = new ScopedInMemoryCache(data);
-
-            // Act
-            const result = cache.clone();
-
-            // Assert
-            expect(result).not.toBe(data);
-        });
-
-        it("should throw if there is an error during cloning", () => {
-            // Arrange
-            const cache = new ScopedInMemoryCache({
-                scope1: {key: "2"},
-                scope2: {key: "1"},
-                scope3: {key: "2"},
-            });
-            jest.spyOn(WSCore, "clone").mockImplementationOnce(() => {
-                throw new Error("BANG!");
-            });
-
-            // Act
-            const act = () => cache.clone();
-
-            // Assert
-            expect(act).toThrowErrorMatchingInlineSnapshot(
-                `"An error occurred while trying to clone the cache: Error: BANG!"`,
-            );
-        });
-    });
-
     describe("@inUse", () => {
         it("should return true if the cache contains data", () => {
             // Arrange

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

@@ -0,0 +1,398 @@
+// @flow
+import * as WSCore from "@khanacademy/wonder-stuff-core";
+import {SerializableInMemoryCache} from "../serializable-in-memory-cache.js";
+
+describe("SerializableInMemoryCache", () => {
+    describe("#constructor", () => {
+        it("should clone the passed source data", () => {
+            // Arrange
+            const sourceData = {
+                scope: {
+                    key: "value",
+                },
+            };
+
+            // Act
+            const cache = new SerializableInMemoryCache(sourceData);
+            // Try to mutate the cache.
+            sourceData["scope"] = {key: "SOME_NEW_DATA"};
+            const result = cache.get("scope", "key");
+
+            // Assert
+            expect(result).toStrictEqual("value");
+        });
+
+        it("should throw if the cloning fails", () => {
+            // Arrange
+            jest.spyOn(WSCore, "clone").mockImplementationOnce(() => {
+                throw new Error("BANG!");
+            });
+
+            // Act
+            const underTest = () =>
+                new SerializableInMemoryCache({
+                    scope: {
+                        BAD: "FOOD",
+                    },
+                });
+
+            // Assert
+            expect(underTest).toThrowErrorMatchingInlineSnapshot(
+                `"An error occurred trying to initialize from a response cache snapshot: Error: BANG!"`,
+            );
+        });
+    });
+
+    describe("#set", () => {
+        it.each`
+            id
+            ${null}
+            ${""}
+            ${5}
+            ${() => "BOO"}
+        `("should throw if the id is $id", ({id}) => {
+            // Arrange
+            const cache = new SerializableInMemoryCache();
+
+            // Act
+            const underTest = () => cache.set("scope", id, "value");
+
+            // Assert
+            expect(underTest).toThrowErrorMatchingSnapshot();
+        });
+
+        it.each`
+            scope
+            ${null}
+            ${""}
+            ${5}
+            ${() => "BOO"}
+        `("should throw if the scope is $scope", ({scope}) => {
+            // Arrange
+            const cache = new SerializableInMemoryCache();
+
+            // Act
+            const underTest = () => cache.set(scope, "key", "value");
+
+            // Assert
+            expect(underTest).toThrowErrorMatchingSnapshot();
+        });
+
+        it("should throw if the value is a function", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache();
+
+            // Act
+            const underTest = () => cache.set("scope", "key", () => "value");
+
+            // Assert
+            expect(underTest).toThrowErrorMatchingSnapshot();
+        });
+
+        it("should store the entry in the cache", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache();
+
+            // Act
+            cache.set("scope", "key", "data");
+            const result = cache.get("scope", "key");
+
+            // Assert
+            expect(result).toStrictEqual("data");
+        });
+
+        it("should replace the entry in the cache", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope: {
+                    key: "data",
+                },
+            });
+
+            // Act
+            cache.set("scope", "key", "other_data");
+            const result = cache.get("scope", "key");
+
+            // Assert
+            expect(result).toStrictEqual("other_data");
+        });
+    });
+
+    describe("#retrieve", () => {
+        it("should return null if the scope is not cached", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache();
+
+            // Act
+            const result = cache.get("scope", "key");
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return null if the value is not in the cache scope", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope: {
+                    key1: "data",
+                },
+            });
+
+            // Act
+            const result = cache.get("scope", "key2");
+
+            // Assert
+            expect(result).toBeNull();
+        });
+
+        it("should return the entry if it exists", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope: {key: "value"},
+            });
+
+            // Act
+            const result = cache.get("scope", "key");
+
+            // Assert
+            expect(result).toStrictEqual("value");
+        });
+    });
+
+    describe("#purge", () => {
+        it("should remove the entry", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+
+            // Act
+            cache.purge("scope1", "key2");
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({
+                scope1: {
+                    key1: "data1",
+                },
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+        });
+
+        it("should remove the entire scope if the purged item is the last item in the scope", () => {
+            const cache = new SerializableInMemoryCache({
+                scope1: {
+                    key2: "data2",
+                },
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+
+            // Act
+            cache.purge("scope1", "key2");
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+        });
+    });
+
+    describe("#purgeScope", () => {
+        it("should remove matching entries only", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {
+                    key1: "a",
+                    key2: "b",
+                    key3: "a",
+                },
+                scope2: {
+                    key1: "a",
+                    key2: "b",
+                    key3: "a",
+                },
+            });
+
+            // Act
+            cache.purgeScope("scope1", (id, value) => value === "a");
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({
+                scope1: {
+                    key2: "b",
+                },
+                scope2: {
+                    key1: "a",
+                    key2: "b",
+                    key3: "a",
+                },
+            });
+        });
+
+        it("should remove the entire scope when there is no predicate", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+
+            // Act
+            cache.purgeScope("scope1");
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({
+                scope2: {
+                    key1: "data1",
+                    key2: "data2",
+                },
+            });
+        });
+
+        it("should not throw if the scope does not exist", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {
+                    key1: "data1",
+                },
+            });
+
+            // Act
+            const act = () => cache.purgeScope("scope2");
+
+            // Arrange
+            expect(act).not.toThrow();
+        });
+    });
+
+    describe("#purgeAll", () => {
+        it("should remove matching entries only", () => {
+            const cache = new SerializableInMemoryCache({
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            });
+
+            // Act
+            cache.purgeAll((scope, id, value) => value === "2");
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({
+                scope2: {key: "1"},
+            });
+        });
+
+        it("should remove the all items if there is no predicate", () => {
+            const cache = new SerializableInMemoryCache({
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            });
+
+            // Act
+            cache.purgeAll();
+            const result = cache.clone();
+
+            // Assert
+            expect(result).toStrictEqual({});
+        });
+    });
+
+    describe("#clone", () => {
+        it("should return a copy of the cache data", () => {
+            // Arrange
+            const data = {
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            };
+            const cache = new SerializableInMemoryCache(data);
+
+            // Act
+            const result = cache.clone();
+
+            // Assert
+            expect(result).not.toBe(data);
+        });
+
+        it("should throw if there is an error during cloning", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            });
+            jest.spyOn(WSCore, "clone").mockImplementationOnce(() => {
+                throw new Error("BANG!");
+            });
+
+            // Act
+            const act = () => cache.clone();
+
+            // Assert
+            expect(act).toThrowErrorMatchingInlineSnapshot(`
+                "An error occurred while trying to clone the cache
+                	caused by
+                		Error: BANG!"
+            `);
+        });
+    });
+
+    describe("@inUse", () => {
+        it("should return true if the cache contains data", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            });
+
+            // Act
+            const result = cache.inUse;
+
+            // Assert
+            expect(result).toBeTruthy();
+        });
+
+        it("should return false if the cache is empty", () => {
+            // Arrange
+            const cache = new SerializableInMemoryCache({
+                scope1: {key: "2"},
+                scope2: {key: "1"},
+                scope3: {key: "2"},
+            });
+            cache.purgeAll();
+
+            // Act
+            const result = cache.inUse;
+
+            // Assert
+            expect(result).toBeFalsy();
+        });
+    });
+});