import { describe, expect, it } from "vitest"; import { MemoryIndexedDbFactory } from "../helpers/memory-indexeddb.ts"; /** * 05-08. Where the fake used to part from native IndexedDB, each case pins * the native result, so a test built on the fake cannot pass on a behavior no * browser has. */ function settle(request: IDBRequest): Promise { return new Promise((resolve, reject) => { request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); }); } function outcome(transaction: IDBTransaction): Promise { return new Promise((resolve) => { transaction.oncomplete = () => resolve("complete"); transaction.onabort = () => resolve(`abort:${transaction.error?.name ?? "none"}`); }); } async function openWithStore( memory: MemoryIndexedDbFactory, name: string, ): Promise { const request = memory.factory.open(name, 1); request.onupgradeneeded = () => { request.result.createObjectStore("s", { keyPath: "k" }); }; return await settle(request); } describe("05-08 memory IndexedDB matches native semantics the adapters rely on", () => { it("(a) runs overlapping readwrite transactions one after another", async () => { const memory = new MemoryIndexedDbFactory(); const database = await openWithStore(memory, "a"); memory.seed("s", { k: "counter", n: 0 }); const first = database.transaction(["s"], "readwrite"); const second = database.transaction(["s"], "readwrite"); const settled = [outcome(first), outcome(second)]; for (const transaction of [first, second]) { const read = transaction.objectStore("s").get("counter"); read.onsuccess = () => { const { n } = read.result as { n: number }; transaction.objectStore("s").put({ k: "counter", n: n + 1 }); }; } expect(await Promise.all(settled)).toEqual(["complete", "complete"]); expect(memory.readRaw("s", "counter")).toEqual({ k: "counter", n: 2 }); }); it("(b) rejects a request placed after the transaction's task ended", async () => { const memory = new MemoryIndexedDbFactory(); const database = await openWithStore(memory, "b"); const transaction = database.transaction(["s"], "readwrite"); const settled = outcome(transaction); await new Promise((resolve) => setTimeout(resolve, 5)); expect(() => transaction.objectStore("s").put({ k: "late" }), ).toThrow(expect.objectContaining({ name: "TransactionInactiveError" })); // A transaction with no request left commits on its own. expect(await settled).toBe("complete"); expect(memory.readRaw("s", "late")).toBeUndefined(); }); it("(b) keeps a transaction active for requests placed in a success callback's microtasks", async () => { const memory = new MemoryIndexedDbFactory(); const database = await openWithStore(memory, "b2"); const transaction = database.transaction(["s"], "readwrite"); const settled = outcome(transaction); const read = transaction.objectStore("s").get("absent"); read.onsuccess = () => { void Promise.resolve().then(() => { transaction.objectStore("s").put({ k: "chained" }); }); }; expect(await settled).toBe("complete"); expect(memory.readRaw("s", "chained")).toEqual({ k: "chained" }); }); it("(d) keeps databases of different names apart", async () => { const memory = new MemoryIndexedDbFactory(); const userA = await openWithStore(memory, "user-A"); await settle( userA.transaction(["s"], "readwrite").objectStore("s").put({ k: "secret-of-A", }), ); let upgraded = false; const request = memory.factory.open("user-B", 1); request.onupgradeneeded = () => { upgraded = true; request.result.createObjectStore("s", { keyPath: "k" }); }; const userB = await settle(request); expect(upgraded).toBe(true); expect( await settle( userB.transaction(["s"], "readonly").objectStore("s").get( "secret-of-A", ), ), ).toBeUndefined(); expect( await settle( userA.transaction(["s"], "readonly").objectStore("s").get( "secret-of-A", ), ), ).toEqual({ k: "secret-of-A" }); }); });