test(#19|#17) write tests for cache (#21)

* test(#19|#17) write tests for cache

* ci(test): run unit tests in ci

Author: faessler

.github/workflows/test.yml

@@ -33,6 +33,10 @@ jobs:
         run: npm ci && npm run build
         working-directory: ./
 
+      - name: Test Unit
+        run: npm run test:cover
+        working-directory: ./
+
       - name: dotenv
         run: echo "${{ secrets.ENV_FILE }}" >> .env
 
@@ -42,5 +46,5 @@ jobs:
       - name: Seed
         run: npm run seed:example
 
-      - name: Test
+      - name: Test Integration
         run: npm run test:cover

package-lock.json

@@ -41,13 +41,16 @@
     "check": "biome check",
     "check:fix": "biome check --write",
     "test:ts:back": "run -T tsc -p server/tsconfig.json",
+    "test:cover": "vitest run ./server --coverage",
+    "test:watch": "vitest watch ./server",
     "release": "semantic-release"
   },
   "devDependencies": {
     "@biomejs/biome": "2.3.2",
     "@strapi/sdk-plugin": "^5",
     "@strapi/strapi": "^5",
     "@strapi/typescript-utils": "^5",
+    "@vitest/coverage-v8": "^4.0.6",
     "semantic-release": "^25.0.1",
     "typescript": "^5.9.3",
     "vitest": "^4.0.6"

package.json

@@ -2,7 +2,7 @@ import type { UID } from "@strapi/strapi";
 
 // memory cache to only execute query generation ones per modelUid
 // biome-ignore lint/suspicious/noExplicitAny: any object can be cached
-const queryCache: Partial<Record<UID.Schema, any>> = {};
+export const queryCache: Partial<Record<UID.Schema, any>> = {};
 
 export const getPopulateQuery = (
   modelUid: UID.Schema,

server/src/utils/getPopulateQuery.ts

@@ -0,0 +1,85 @@
+import type { UID } from "@strapi/strapi";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { getPopulateQuery, queryCache } from "../getPopulateQuery";
+
+describe("getPopulateQuery: cache", () => {
+  const mockStrapi = {
+    log: { debug: vi.fn() },
+    getModel: vi.fn(),
+    plugin: vi.fn().mockReturnValue({ config: vi.fn() }),
+  };
+
+  beforeEach(() => {
+    // @ts-expect-error enough to mock
+    global.strapi = mockStrapi;
+    mockStrapi.log.debug.mockClear();
+    mockStrapi.getModel.mockClear();
+    mockStrapi.plugin.mockClear();
+
+    // reset cache
+    Object.keys(queryCache).forEach((key) => {
+      delete queryCache[key];
+    });
+  });
+
+  test("uses cache by default", () => {
+    mockStrapi.getModel.mockReturnValue({
+      attributes: { media: { type: "media" } },
+    });
+
+    getPopulateQuery("model" as UID.Schema);
+
+    expect(queryCache).toEqual({ model: { populate: { media: true } } });
+  });
+
+  test("uses cache if enabled", () => {
+    mockStrapi.plugin.mockReturnValue({
+      config: vi
+        .fn()
+        .mockImplementation((key) => (key === "cache" ? true : undefined)),
+    });
+    mockStrapi.getModel.mockReturnValue({
+      attributes: { media: { type: "media" } },
+    });
+
+    getPopulateQuery("model" as UID.Schema);
+
+    expect(queryCache).toEqual({ model: { populate: { media: true } } });
+  });
+
+  test("skips cache if disabled", () => {
+    mockStrapi.plugin.mockReturnValue({
+      config: vi
+        .fn()
+        .mockImplementation((key) => (key === "cache" ? false : undefined)),
+    });
+    mockStrapi.getModel.mockReturnValue({
+      attributes: { media: { type: "media" } },
+    });
+
+    getPopulateQuery("model" as UID.Schema);
+
+    expect(queryCache).toEqual({});
+  });
+
+  test("cache does not mutate original object", () => {
+    mockStrapi.plugin.mockReturnValue({
+      config: vi
+        .fn()
+        .mockImplementation((key) => (key === "cache" ? true : undefined)),
+    });
+    mockStrapi.getModel.mockReturnValue({
+      attributes: {
+        media: { type: "media" },
+      },
+    });
+
+    const result = getPopulateQuery("model" as UID.Schema);
+    // @ts-expect-error: simulating race condition where `queryCache` gets overwritten by other call
+    queryCache.model.populate.media = false;
+
+    expect(result).toEqual({
+      populate: { media: true },
+    });
+  });
+});