1 files changed, 95 insertions, 0 deletions
diff --git a/test/cdp/record-store-test.ts b/test/cdp/record-store-test.ts
new file mode 100644
index 0000000..c259f87
--- /dev/null
+++ b/test/cdp/record-store-test.ts
@@ -0,0 +1,95 @@
+import { test, describe } from "node:test";
+import assert from "node:assert/strict";
+import { createRecordStore } from "../../src/cdp/record-store";
+
+const fill = (store: ReturnType<typeof createRecordStore<number, string>>, n: number): void => {
+  for (let i = 1; i <= n; i++) store.set(i, `r${i}`);
+};
+
+describe("record store capacity", () => {
+  test("holds up to capacity without reporting a loss", () => {
+    const store = createRecordStore<number, string>(3);
+    fill(store, 3);
+    assert.equal([...store.values()].length, 3);
+    assert.equal(store.page([...store.values()], undefined).bufferOverflowed, false);
+  });
+
+  test("evicts the oldest past capacity and reports the loss", () => {
+    const store = createRecordStore<number, string>(3);
+    fill(store, 5);
+    assert.deepEqual([...store.values()], ["r3", "r4", "r5"]);
+    assert.equal(store.page([...store.values()], undefined).bufferOverflowed, true);
+  });
+
+  test("the overflow flag is taken, so a second drain reports no new loss", () => {
+    const store = createRecordStore<number, string>(2);
+    fill(store, 4);
+    assert.equal(store.page([], undefined).bufferOverflowed, true);
+    assert.equal(store.page([], undefined).bufferOverflowed, false);
+  });
+
+  test("clear resets both the records and the overflow flag", () => {
+    const store = createRecordStore<number, string>(2);
+    fill(store, 4);
+    store.clear();
+    assert.equal([...store.values()].length, 0);
+    assert.equal(store.page([], undefined).bufferOverflowed, false);
+  });
+
+  test("get returns the stored object by reference so callers can mutate in place", () => {
+    const store = createRecordStore<string, { status?: number }>(4);
+    store.set("a", {});
+    const held = store.get("a");
+    assert.ok(held);
+    held.status = 200;
+    assert.equal(store.get("a")?.status, 200);
+  });
+
+  test("delete removes a record without flagging an overflow", () => {
+    const store = createRecordStore<number, string>(4);
+    fill(store, 2);
+    store.delete(1);
+    assert.deepEqual([...store.values()], ["r2"]);
+    assert.equal(store.page([], undefined).bufferOverflowed, false);
+  });
+
+  test("re-setting an existing key does not grow the store", () => {
+    const store = createRecordStore<number, string>(4);
+    store.set(1, "first");
+    store.set(1, "second");
+    assert.deepEqual([...store.values()], ["second"]);
+  });
+});
+
+describe("record store paging", () => {
+  test("total counts every match while records carry only the page", () => {
+    const store = createRecordStore<number, string>(100);
+    const matched = Array.from({ length: 120 }, (_, i) => `r${i}`);
+    const page = store.page(matched, 10);
+    assert.equal(page.total, 120);
+    assert.equal(page.records.length, 10);
+  });
+
+  test("the page is the newest records, not the oldest", () => {
+    const store = createRecordStore<number, string>(10);
+    const page = store.page(["a", "b", "c"], 2);
+    assert.deepEqual(page.records, ["b", "c"]);
+  });
+
+  test("an absent limit defaults to 50", () => {
+    const store = createRecordStore<number, string>(600);
+    const matched = Array.from({ length: 80 }, (_, i) => `r${i}`);
+    assert.equal(store.page(matched, undefined).records.length, 50);
+  });
+
+  test("a limit above the 500 ceiling is capped", () => {
+    const store = createRecordStore<number, string>(1000);
+    const matched = Array.from({ length: 700 }, (_, i) => `r${i}`);
+    assert.equal(store.page(matched, 9_000).records.length, 500);
+  });
+
+  test("a limit larger than the match count returns every match", () => {
+    const store = createRecordStore<number, string>(10);
+    assert.equal(store.page(["a", "b"], 50).records.length, 2);
+  });
+});