The fake let overlapping readwrite transactions overwrite each other, took requests after the transaction's task ended and shared rows across database names, so adapter tests could pass on behavior no browser has. It now keeps one database per name, runs overlapping transactions in order, throws TransactionInactiveError for late requests, and its header lists what it still does not model. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
121 lines
4.2 KiB
TypeScript
121 lines
4.2 KiB
TypeScript
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<Value>(request: IDBRequest<Value>): Promise<Value> {
|
|
return new Promise((resolve, reject) => {
|
|
request.onsuccess = () => resolve(request.result);
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
}
|
|
|
|
function outcome(transaction: IDBTransaction): Promise<string> {
|
|
return new Promise((resolve) => {
|
|
transaction.oncomplete = () => resolve("complete");
|
|
transaction.onabort = () =>
|
|
resolve(`abort:${transaction.error?.name ?? "none"}`);
|
|
});
|
|
}
|
|
|
|
async function openWithStore(
|
|
memory: MemoryIndexedDbFactory,
|
|
name: string,
|
|
): Promise<IDBDatabase> {
|
|
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" });
|
|
});
|
|
});
|