Initial Commit

packages/networking/drive/drive-plugin-cache/tests/integration/with-memory-cache.test.ts

@@ -0,0 +1,65 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MemoryCache } from "@suaveplan/cache";
+import { Drive } from "@suaveplan/drive";
+import { createNodeFsStorage } from "@suaveplan/storage-file";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "@suaveplan/testing/runner";
+import { driveCachePlugin } from "../../src/plugin/plugin.js";
+
+describe("drive-plugin-cache integration: MemoryCache", () => {
+    let rootDir: string;
+    let drive: Drive;
+
+    beforeEach(async () => {
+        rootDir = mkdtempSync(join(tmpdir(), "drive-plugin-cache-mem-"));
+        const fileStorage = createNodeFsStorage({ rootDir, mkdirp: true });
+        const storage = Object.assign(fileStorage, { id: "default" });
+        drive = new Drive(storage);
+        await drive.initialize();
+    });
+
+    afterEach(async () => {
+        await drive.dispose();
+        rmSync(rootDir, { recursive: true, force: true });
+    });
+
+    it("second read of the same path is served from the cache", {
+        timeout: 30000,
+    }, async () => {
+        const cache = new MemoryCache<Uint8Array>({ maxSize: 100 });
+        const handle = await drive.usePlugin(driveCachePlugin({ cache }));
+        const payload = new Uint8Array([0x4d, 0x4f, 0x56, 0x21]);
+        await drive.write("clip.mov", payload);
+        const bytes1 = await drive.read("clip.mov");
+        const bytes2 = await drive.read("clip.mov");
+        expect(Array.from(bytes1)).toEqual(Array.from(payload));
+        expect(Array.from(bytes2)).toEqual(Array.from(payload));
+        const stats = handle.getStats();
+        expect(stats.hits).toBe(1);
+        expect(stats.misses).toBe(1);
+        expect(stats.populations).toBe(1);
+    });
+
+    it("write invalidates a previously populated entry", {
+        timeout: 30000,
+    }, async () => {
+        const cache = new MemoryCache<Uint8Array>({ maxSize: 100 });
+        const handle = await drive.usePlugin(driveCachePlugin({ cache }));
+        await drive.write("x.bin", new Uint8Array([1, 2, 3]));
+        await drive.read("x.bin"); // populates
+        await drive.write("x.bin", new Uint8Array([9, 9, 9])); // invalidates
+        const fresh = await drive.read("x.bin");
+        expect(Array.from(fresh)).toEqual([9, 9, 9]);
+        // Two writes → two post-success invalidations. The first targets an
+        // unpopulated key (idempotent on the cache); the second actually
+        // evicts the populated entry produced by the intermediate read.
+        expect(handle.getStats().invalidations).toBe(2);
+    });
+});