Add caching tests for when getCacheIdentifier is asynchronous

.changeset/stupid-pandas-greet.md

@@ -0,0 +1,5 @@
+---
+'@lion/ajax': patch
+---
+
+Add caching tests for when getCacheIdentifier is asynchronous

packages/ajax/test/Ajax.test.js

@@ -451,6 +451,8 @@ describe('Ajax', () => {
     let cacheId;
     /** @type {() => string} */
     let getCacheIdentifier;
+    /** @type {() => Promise<string>} */
+    let getCacheIdentifierAsync;
 
     const newCacheId = () => {
       if (!cacheId) {
@@ -463,6 +465,7 @@ describe('Ajax', () => {
 
     beforeEach(() => {
       getCacheIdentifier = () => String(cacheId);
+      getCacheIdentifierAsync = () => Promise.resolve(String(cacheId));
     });
 
     it('does not add cache interceptors when useCache is turned off', () => {
@@ -503,24 +506,8 @@ describe('Ajax', () => {
       expect(customAjax._responseInterceptors.length).to.equal(1);
     });
 
-    describe('Caching interceptors: synchronous getCacheIdentifier tests', async () => {
+    const cachingTests = {};
-      /**
+    cachingTests.works = async (/** @type {Ajax} */ customAjax) => {
-       * @type {Ajax}
-       */
-      let customAjax;
-
-      beforeEach(async () => {
-        newCacheId();
-        customAjax = new Ajax({
-          cacheOptions: {
-            useCache: true,
-            maxAge: 100,
-            getCacheIdentifier,
-          },
-        });
-      });
-
-      it('works', async () => {
       await customAjax.fetch('/foo');
 
       const secondResponse = await customAjax.fetch('/foo');
@@ -528,9 +515,9 @@ describe('Ajax', () => {
       expect(await secondResponse.text()).to.equal('mock response');
       expect(secondResponse.headers.get('X-Custom-Header')).to.equal('y-custom-value');
       expect(secondResponse.headers.get('Content-Type')).to.equal('application/json');
-      });
+    };
 
-      it('resets the cache if the cache ID changes', async () => {
+    cachingTests.resetOnCacheIDChange = async (/** @type {Ajax} */ customAjax) => {
       /* Three calls to the same endpoint should result in a 
         single fetchStubCall due to caching */
       await customAjax.fetch('/foo');
@@ -544,17 +531,17 @@ describe('Ajax', () => {
       /* The newCacheId call should reset the cache, thereby adding an
       extra call to the fetchStub call count. */
       expect(fetchStub.callCount).to.equal(2);
-      });
+    };
 
-      it('Completes pending requests when the cache ID changes', async () => {
+    cachingTests.completePendingOnCacheIDChange = async (/** @type {Ajax} */ customAjax) => {
       const requestOne = customAjax.fetch('/foo').then(() => 'completedRequestOne');
       newCacheId();
       const requestTwo = customAjax.fetch('/foo').then(() => 'completedRequestTwo');
       expect(await requestOne).to.equal('completedRequestOne');
       expect(await requestTwo).to.equal('completedRequestTwo');
-      });
+    };
 
-      it('works with fetchJson', async () => {
+    cachingTests.worksWithFetchJson = async (/** @type {Ajax} */ customAjax) => {
       fetchStub.returns(Promise.resolve(new Response('{"a":1,"b":2}', responseInit())));
 
       const firstResponse = await customAjax.fetchJson('/foo');
@@ -567,9 +554,9 @@ describe('Ajax', () => {
       expect(secondResponse.body).to.deep.equal({ a: 1, b: 2 });
       expect(secondResponse.response.headers.get('X-Custom-Header')).to.equal('y-custom-value');
       expect(secondResponse.response.headers.get('Content-Type')).to.equal('application/json');
-      });
+    };
 
-      it('is invalidated on non-get method', async () => {
+    cachingTests.invalidatesOnNonGetMethod = async (/** @type {Ajax} */ customAjax) => {
       await customAjax.fetch('/foo');
 
       const secondResponse = await customAjax.fetch('/foo', { method: 'POST' });
@@ -583,9 +570,9 @@ describe('Ajax', () => {
       expect(await thirdResponse.text()).to.equal('mock response');
       expect(thirdResponse.headers.get('X-Custom-Header')).to.equal('y-custom-value');
       expect(thirdResponse.headers.get('Content-Type')).to.equal('application/json');
-      });
+    };
 
-      it('is invalidated after TTL has passed', async () => {
+    cachingTests.invalidatesOnTTLPassed = async (/** @type {Ajax} */ customAjax) => {
       const clock = useFakeTimers({
         shouldAdvanceTime: true,
       });
@@ -607,6 +594,89 @@ describe('Ajax', () => {
       expect(thirdResponse.headers.get('Content-Type')).to.equal('application/json');
 
       clock.restore();
+    };
+
+    describe('Caching interceptors: cache tests with synchronous getCacheIdentifier', async () => {
+      /**
+       * @type {Ajax}
+       */
+      let customAjax;
+
+      beforeEach(async () => {
+        newCacheId();
+        customAjax = new Ajax({
+          cacheOptions: {
+            useCache: true,
+            maxAge: 100,
+            getCacheIdentifier,
+          },
+        });
+      });
+
+      it('works', async () => {
+        await cachingTests.works(customAjax);
+      });
+
+      it('resets the cache if the cache ID changes', async () => {
+        await cachingTests.resetOnCacheIDChange(customAjax);
+      });
+
+      it('Completes pending requests when the cache ID changes', async () => {
+        await cachingTests.completePendingOnCacheIDChange(customAjax);
+      });
+
+      it('works with fetchJson', async () => {
+        await cachingTests.worksWithFetchJson(customAjax);
+      });
+
+      it('is invalidated on non-get method', async () => {
+        await cachingTests.invalidatesOnNonGetMethod(customAjax);
+      });
+
+      it('is invalidated after TTL has passed', async () => {
+        await cachingTests.invalidatesOnTTLPassed(customAjax);
+      });
+    });
+
+    describe('Caching interceptors: cache tests with asynchronous getCacheIdentifier', async () => {
+      /**
+       * @type {Ajax}
+       */
+      let customAjax;
+
+      beforeEach(async () => {
+        newCacheId();
+        customAjax = new Ajax({
+          cacheOptions: {
+            useCache: true,
+            maxAge: 100,
+            getCacheIdentifier: getCacheIdentifierAsync,
+          },
+        });
+      });
+
+      it('works', async () => {
+        await cachingTests.works(customAjax);
+      });
+
+      it('resets the cache if the cache ID changes', async () => {
+        await cachingTests.resetOnCacheIDChange(customAjax);
+      });
+
+      it('Completes pending requests when the cache ID changes', async () => {
+        await cachingTests.completePendingOnCacheIDChange(customAjax);
+      });
+
+      it('works with fetchJson', async () => {
+        await cachingTests.worksWithFetchJson(customAjax);
+      });
+
+      it('is invalidated on non-get method', async () => {
+        await cachingTests.invalidatesOnNonGetMethod(customAjax);
+      });
+
+      it('is invalidated after TTL has passed', async () => {
+        await cachingTests.invalidatesOnTTLPassed(customAjax);
       });
     });
   });