@graphql-box/connection-resolver 4.1.4 → 5.0.0

package/src/helpers/retrieveCachedConnection.test.ts

@@ -1,434 +1,653 @@
-import { decode, encode } from "js-base64";
-import generateCursorCache from "../__testUtils__/generateCursorCache";
-import extractEdges from "./extractEdges";
-import retrieveCachedConnection from "./retrieveCachedConnection";
-
-describe("retrieveCachedConnection", () => {
-  const groupCursor = encode("123456789");
+import { expect } from '@jest/globals';
+import { decode, encode } from 'js-base64';
+import { generateCursorCache } from '../__testUtils__/generateCursorCache.ts';
+import { extractEdges } from './extractEdges.ts';
+import { retrieveCachedConnection } from './retrieveCachedConnection.ts';
+
+describe('retrieveCachedConnection', () => {
+  const groupCursor = encode('123456789');
   const resultsPerPage = 10;
 
-  describe("retrieving edges after a cursor", () => {
-    test("when 5 cursors on the same page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        after: `${encode(`0::1`)}::${groupCursor}`,
-        first: 5,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(5);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::1");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::1");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
-
-    test("when 15 cursors covering multiple pages are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        after: `${encode(`5::1`)}::${groupCursor}`,
-        first: 15,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(15);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("6::1");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("0::3");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
-
-    test("when 15 cursors going over the last page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        after: `${encode(`0::10`)}::${groupCursor}`,
-        first: 15,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(9);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::10");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(false);
-      expect(missingPages.length).toBe(0);
-    });
+  describe('retrieving edges after a cursor', () => {
+    describe('when 5 cursors on the same page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
 
-    describe("when 35 cursors covering multiple pages and going OVER the last page are requested", () => {
-      test("when last page has full page of results", async () => {
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 35,
+          after: `${encode(`0::1`)}::${groupCursor}`,
+          first: 5,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(5);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::1');
+      });
+
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('5::1');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(29);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(false);
-        expect(missingPages.length).toBe(0);
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
       });
 
-      test("when last page has partial page of results", async () => {
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
+    });
+
+    describe('when 15 cursors covering multiple pages are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
-          totalResults: 96,
+          totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 35,
+          after: `${encode(`5::1`)}::${groupCursor}`,
+          first: 15,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(15);
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(25);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(false);
-        expect(missingPages.length).toBe(0);
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('6::1');
+      });
+
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('0::3');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
+
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
+      });
+
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
       });
     });
 
-    describe("when 25 cursors covering multiple pages and going UP TO the last page are requested", () => {
-      test("when last page has full page of results", async () => {
+    describe('when 15 cursors going over the last page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 25,
+          after: `${encode(`0::10`)}::${groupCursor}`,
+          first: 15,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(9);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::10');
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(25);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(true);
-        expect(missingPages.length).toBe(0);
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::10');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
+
+      it('should return hasNextPage as false', () => {
+        expect(result.hasNextPage).toBe(false);
+      });
+
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
+    });
+
+    describe('when 35 cursors covering multiple pages and going OVER the last page are requested', () => {
+      describe('when last page has full page of results', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 35,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(29);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as false', () => {
+          expect(result.hasNextPage).toBe(false);
+        });
+
+        it('should return no missing pages', () => {
+          expect(result.missingPages).toHaveLength(0);
+        });
       });
 
-      test("when last page has partial page of results", async () => {
+      describe('when last page has partial page of results', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 96,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 35,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(25);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('5::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as false', () => {
+          expect(result.hasNextPage).toBe(false);
+        });
+
+        it('should return no missing pages', () => {
+          expect(result.missingPages).toHaveLength(0);
+        });
+      });
+    });
+
+    describe('when 25 cursors covering multiple pages and going UP TO the last page are requested', () => {
+      describe('when last page has full page of results', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 25,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(25);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('5::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as true', () => {
+          expect(result.hasNextPage).toBe(true);
+        });
+
+        it('should return no missing pages', () => {
+          expect(result.missingPages).toHaveLength(0);
+        });
+      });
+
+      describe('when last page has partial page of results', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 96,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 25,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(25);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('1::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('5::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as false', () => {
+          expect(result.hasNextPage).toBe(false);
+        });
+
+        it('should return no missing pages', () => {
+          expect(result.missingPages).toHaveLength(0);
+        });
+      });
+    });
+
+    describe('when there are missing pages', () => {
+      describe('when 35 cursors covering multiple pages and going OVER the last page are requested', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-8', '10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 35,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(20);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as false', () => {
+          expect(result.hasNextPage).toBe(false);
+        });
+
+        it('should return the missing pages', () => {
+          expect(result.missingPages).toEqual([9]);
+        });
+      });
+
+      describe('when 25 cursors covering multiple pages and going UP TO the last page are requested', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1-8', '10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            after: `${encode(`0::8`)}::${groupCursor}`,
+            first: 25,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(20);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::8');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::10');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as true', () => {
+          expect(result.hasNextPage).toBe(true);
+        });
+
+        it('should return the missing pages', () => {
+          expect(result.missingPages).toEqual([9]);
+        });
+      });
+    });
+  });
+
+  describe('retrieving edges before a cursor', () => {
+    describe('when 5 cursors on the same page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
-          totalResults: 96,
+          totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 25,
+          before: `${encode(`9::10`)}::${groupCursor}`,
+          last: 5,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(5);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('4::10');
+      });
+
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('8::10');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
+
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(25);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("1::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("5::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(false);
-        expect(missingPages.length).toBe(0);
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
       });
     });
 
-    describe("when there are missing pages", () => {
-      test("when 35 cursors covering multiple pages and going OVER the last page are requested", async () => {
+    describe('when 15 cursors covering multiple pages are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-8", "10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 35,
+          before: `${encode(`9::10`)}::${groupCursor}`,
+          last: 15,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(15);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('4::9');
+      });
+
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('8::10');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(20);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(false);
-        expect(missingPages.length).toBe(1);
-        expect(missingPages[0]).toBe(9);
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
       });
 
-      test("when 25 cursors covering multiple pages and going UP TO the last page are requested", async () => {
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
+    });
+
+    describe('when 15 cursors going under the first page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1-8", "10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
         });
 
         const args = {
-          after: `${encode(`0::8`)}::${groupCursor}`,
-          first: 25,
+          before: `${encode(`9::1`)}::${groupCursor}`,
+          last: 15,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(20);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::8");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::10");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(true);
-        expect(missingPages.length).toBe(1);
-        expect(missingPages[0]).toBe(9);
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(9);
       });
-    });
-  });
 
-  describe("retrieving edges before a cursor", () => {
-    test("when 5 cursors on the same page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        before: `${encode(`9::10`)}::${groupCursor}`,
-        last: 5,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(5);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("4::10");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::10");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::1');
+      });
 
-    test("when 15 cursors covering multiple pages are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        before: `${encode(`9::10`)}::${groupCursor}`,
-        last: 15,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(15);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("4::9");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::10");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('8::1');
+      });
 
-    test("when 15 cursors going under the first page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        before: `${encode(`9::1`)}::${groupCursor}`,
-        last: 15,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(9);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("8::1");
-      expect(hasPreviousPage).toBe(false);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
+      it('should return hasPreviousPage as false', () => {
+        expect(result.hasPreviousPage).toBe(false);
+      });
 
-    test("when 35 cursors covering multiple pages and going UNDER the first page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        before: `${encode(`7::3`)}::${groupCursor}`,
-        last: 35,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(27);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("6::3");
-      expect(hasPreviousPage).toBe(false);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
-    });
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
+      });
 
-    test("when 25 cursors covering multiple pages and going DOWN TO the first page are requested", async () => {
-      const cursorCache = await generateCursorCache({
-        group: groupCursor,
-        pageRanges: ["1-10"],
-        resultsPerPage,
-        totalPages: 10,
-        totalResults: 100,
-      });
-
-      const args = {
-        before: `${encode(`7::3`)}::${groupCursor}`,
-        last: 25,
-      };
-
-      const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
-        cursorCache,
-        groupCursor,
-        resultsPerPage,
-      });
-
-      const edges = extractEdges(cachedEdges);
-      expect(edges.length).toBe(25);
-      expect(decode((edges[0].node.id as string).split("::")[0])).toBe("2::1");
-      expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("6::3");
-      expect(hasPreviousPage).toBe(true);
-      expect(hasNextPage).toBe(true);
-      expect(missingPages.length).toBe(0);
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
     });
 
-    describe("when there are missing pages", () => {
-      test("when 35 cursors covering multiple pages and going UNDER the first page are requested", async () => {
+    describe('when 35 cursors covering multiple pages and going UNDER the first page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1", "3-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
@@ -439,26 +658,48 @@ describe("retrieveCachedConnection", () => {
           last: 35,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(27);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::1');
+      });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(20);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::3");
-        expect(hasPreviousPage).toBe(false);
-        expect(hasNextPage).toBe(true);
-        expect(missingPages.length).toBe(1);
-        expect(missingPages[0]).toBe(2);
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('6::3');
       });
 
-      test("when 25 cursors covering multiple pages and going DOWN TO the first page are requested", async () => {
+      it('should return hasPreviousPage as false', () => {
+        expect(result.hasPreviousPage).toBe(false);
+      });
+
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
+      });
+
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
+    });
+
+    describe('when 25 cursors covering multiple pages and going DOWN TO the first page are requested', () => {
+      let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+      beforeAll(async () => {
         const cursorCache = await generateCursorCache({
           group: groupCursor,
-          pageRanges: ["1", "3-10"],
+          pageRanges: ['1-10'],
           resultsPerPage,
           totalPages: 10,
           totalResults: 100,
@@ -469,20 +710,144 @@ describe("retrieveCachedConnection", () => {
           last: 25,
         };
 
-        const { cachedEdges, hasNextPage, hasPreviousPage, missingPages } = await retrieveCachedConnection(args, {
+        result = await retrieveCachedConnection(args, {
           cursorCache,
           groupCursor,
           resultsPerPage,
         });
+      });
+
+      it('should return the correct number of edges', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(edges).toHaveLength(25);
+      });
+
+      it('should return the correct first edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('2::1');
+      });
+
+      it('should return the correct last edge', () => {
+        const edges = extractEdges(result.cachedEdges);
+        expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('6::3');
+      });
+
+      it('should return hasPreviousPage as true', () => {
+        expect(result.hasPreviousPage).toBe(true);
+      });
+
+      it('should return hasNextPage as true', () => {
+        expect(result.hasNextPage).toBe(true);
+      });
+
+      it('should return no missing pages', () => {
+        expect(result.missingPages).toHaveLength(0);
+      });
+    });
+
+    describe('when there are missing pages', () => {
+      describe('when 35 cursors covering multiple pages and going UNDER the first page are requested', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1', '3-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            before: `${encode(`7::3`)}::${groupCursor}`,
+            last: 35,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(20);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::1');
+        });
 
-        const edges = extractEdges(cachedEdges);
-        expect(edges.length).toBe(20);
-        expect(decode((edges[0].node.id as string).split("::")[0])).toBe("0::1");
-        expect(decode((edges[edges.length - 1].node.id as string).split("::")[0])).toBe("9::3");
-        expect(hasPreviousPage).toBe(true);
-        expect(hasNextPage).toBe(true);
-        expect(missingPages.length).toBe(1);
-        expect(missingPages[0]).toBe(2);
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::3');
+        });
+
+        it('should return hasPreviousPage as false', () => {
+          expect(result.hasPreviousPage).toBe(false);
+        });
+
+        it('should return hasNextPage as true', () => {
+          expect(result.hasNextPage).toBe(true);
+        });
+
+        it('should return the missing pages', () => {
+          expect(result.missingPages).toEqual([2]);
+        });
+      });
+
+      describe('when 25 cursors covering multiple pages and going DOWN TO the first page are requested', () => {
+        let result: Awaited<ReturnType<typeof import('./retrieveCachedConnection.ts')['retrieveCachedConnection']>>;
+
+        beforeAll(async () => {
+          const cursorCache = await generateCursorCache({
+            group: groupCursor,
+            pageRanges: ['1', '3-10'],
+            resultsPerPage,
+            totalPages: 10,
+            totalResults: 100,
+          });
+
+          const args = {
+            before: `${encode(`7::3`)}::${groupCursor}`,
+            last: 25,
+          };
+
+          result = await retrieveCachedConnection(args, {
+            cursorCache,
+            groupCursor,
+            resultsPerPage,
+          });
+        });
+
+        it('should return the correct number of edges', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(edges).toHaveLength(20);
+        });
+
+        it('should return the correct first edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[0]!.node.id as string).split('::')[0]!)).toBe('0::1');
+        });
+
+        it('should return the correct last edge', () => {
+          const edges = extractEdges(result.cachedEdges);
+          expect(decode((edges[edges.length - 1]!.node.id as string).split('::')[0]!)).toBe('9::3');
+        });
+
+        it('should return hasPreviousPage as true', () => {
+          expect(result.hasPreviousPage).toBe(true);
+        });
+
+        it('should return hasNextPage as true', () => {
+          expect(result.hasNextPage).toBe(true);
+        });
+
+        it('should return the missing pages', () => {
+          expect(result.missingPages).toEqual([2]);
+        });
       });
     });
   });