@khanacademy/wonder-blocks-data 5.0.1 → 7.0.0

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

@@ -1,6 +1,6 @@
 // @flow
-import {SsrCache} from "../ssr-cache.js";
 import {RequestFulfillment} from "../request-fulfillment.js";
+import {DataError} from "../data-error.js";
 
 describe("RequestFulfillment", () => {
     it("should provide static default instance", () => {
@@ -15,62 +15,44 @@ describe("RequestFulfillment", () => {
     });
 
     describe("#fulfill", () => {
-        it("should attempt to cache errors caused directly by handlers", async () => {
+        it("should resolve to an error result", async () => {
             // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
-            const error = new Error("OH NO!");
-            const fakeBadHandler = () => {
-                throw error;
-            };
-            const cacheErrorSpy = jest.spyOn(responseCache, "cacheError");
+            const requestFulfillment = new RequestFulfillment();
+            const fakeBadRequestHandler = () => Promise.reject("OH NO!");
 
             // Act
-            await requestFulfillment.fulfill("ID", {
-                handler: fakeBadHandler,
+            const result = await requestFulfillment.fulfill("ID", {
+                handler: fakeBadRequestHandler,
             });
 
             // Assert
-            expect(cacheErrorSpy).toHaveBeenCalledWith("ID", error, true);
+            expect(result).toStrictEqual({
+                status: "error",
+                error: expect.any(DataError),
+            });
         });
 
-        it("should cache errors occurring in promises", async () => {
+        it("should resolve to an aborted result", async () => {
             // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
-            const fakeBadRequestHandler = () =>
-                new Promise((resolve, reject) => reject("OH NO!"));
-            const cacheErrorSpy = jest.spyOn(responseCache, "cacheError");
+            const requestFulfillment = new RequestFulfillment();
+            const abortError = new Error("abort abort abort, awoooga");
+            abortError.name = "AbortError";
+            const fakeBadRequestHandler = () => Promise.reject(abortError);
 
             // Act
-            await requestFulfillment.fulfill("ID", {
+            const result = await requestFulfillment.fulfill("ID", {
                 handler: fakeBadRequestHandler,
             });
 
             // Assert
-            expect(cacheErrorSpy).toHaveBeenCalledWith("ID", "OH NO!", true);
-        });
-
-        it("should cache data from requests", async () => {
-            // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
-            const fakeRequestHandler = () => Promise.resolve("DATA!");
-            const cacheDataSpy = jest.spyOn(responseCache, "cacheData");
-
-            // Act
-            await requestFulfillment.fulfill("ID", {
-                handler: fakeRequestHandler,
+            expect(result).toStrictEqual({
+                status: "aborted",
             });
-
-            // Assert
-            expect(cacheDataSpy).toHaveBeenCalledWith("ID", "DATA!", true);
         });
 
-        it("should return a promise of the result", async () => {
+        it("should resolve to a data result", async () => {
             // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
+            const requestFulfillment = new RequestFulfillment();
             const fakeRequestHandler = () => Promise.resolve("DATA!");
 
             // Act
@@ -80,14 +62,14 @@ describe("RequestFulfillment", () => {
 
             // Assert
             expect(result).toStrictEqual({
+                status: "success",
                 data: "DATA!",
             });
         });
 
         it("should reuse inflight requests", () => {
             // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
+            const requestFulfillment = new RequestFulfillment();
             const fakeRequestHandler = () => Promise.resolve("DATA!");
 
             // Act
@@ -104,8 +86,7 @@ describe("RequestFulfillment", () => {
 
         it("should remove inflight requests upon completion", async () => {
             // Arrange
-            const responseCache = new SsrCache();
-            const requestFulfillment = new RequestFulfillment(responseCache);
+            const requestFulfillment = new RequestFulfillment();
             const fakeRequestHandler = () => Promise.resolve("DATA!");
 
             // Act

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