Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

7.3 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { IDBKeyRange as FakeIDBKeyRange, IDBFactory } from "fake-indexeddb";
import {
  openRecorderDatabase,
  RECORDER_DATABASE,
  RECORDER_DATABASE_VERSION,
  requestToPromise,
  STORES,
  tx,
} from "../src/shared/database";

// Installed per test rather than by "fake-indexeddb/auto": that import sets the globals once at module
// load, and another file's teardown in the same `bun test` process can delete them afterwards.
type IndexedDbGlobals = {
  indexedDB?: IDBFactory;
  IDBKeyRange?: typeof FakeIDBKeyRange;
};
const globals = globalThis as unknown as IndexedDbGlobals;
let saved: IndexedDbGlobals = {};

beforeEach(() => {
  saved = { indexedDB: globals.indexedDB, IDBKeyRange: globals.IDBKeyRange };
  globals.indexedDB = new IDBFactory();
  globals.IDBKeyRange = FakeIDBKeyRange;
});

afterEach(() => {
  for (const key of ["indexedDB", "IDBKeyRange"] as const) {
    if (saved[key] === undefined) Reflect.deleteProperty(globals, key);
    else Object.assign(globals, { [key]: saved[key] });
  }
});

let counter = 0;
const freshName = () => `recorder-test-${Date.now()}-${counter++}`;

const keyPathOf = (db: IDBDatabase, store: string) =>
  db.transaction(store, "readonly").objectStore(store).keyPath;

describe("recorder database", () => {
  test("declares the default name and version 2", () => {
    expect(RECORDER_DATABASE).toBe("openbot-recorder");
    expect(RECORDER_DATABASE_VERSION).toBe(2);
  });

  test("a version 1 database an old build left drops its other stores, meta keys and demonstration trajectories, and keeps the outbox", async () => {
    const name = freshName();
    await new Promise<void>((resolve, reject) => {
      const request = indexedDB.open(name, 1);
      request.onupgradeneeded = () => {
        const db = request.result;
        db.createObjectStore("events", { keyPath: ["trajectoryId", "seq"] });
        const meta = db.createObjectStore("meta");
        db.createObjectStore("media", { keyPath: ["mediaId", "index"] });
        db.createObjectStore("voice", {
          keyPath: ["demonstrationId", "index"],
        });
        db.createObjectStore("steps", {
          keyPath: ["demonstrationId", "index"],
        });
        db.createObjectStore("bodies", { keyPath: ["mediaId", "line"] });
        meta.put(7, "seq");
        meta.put({ recordingId: "rec-1", title: "T" }, "trajectory:t-new");
        meta.put({ demonstrationId: "demo-1", title: "T" }, "trajectory:t-old");
        meta.put("media-1", "media:demo-1:screen");
        meta.put(3, "bodies-next:media-1");
        meta.put({ chunks: 1, offset: 0 }, "bodies-progress:media-1");
        meta.put(2, "steps-next:demo-1");
        const events = request.transaction?.objectStore("events");
        events?.put({ trajectoryId: "t-new", seq: 1 });
        events?.put({ trajectoryId: "t-old", seq: 2 });
        events?.put({ trajectoryId: "t-old", seq: 3 });
      };
      request.onsuccess = () => {
        request.result.close();
        resolve();
      };
      request.onerror = () => reject(request.error);
    });
    const db = await openRecorderDatabase(name);
    expect(db.version).toBe(2);
    expect([...db.objectStoreNames].sort()).toEqual(["events", "meta"]);
    const metaKeys = await tx(db, ["meta"], "readonly", (t) =>
      requestToPromise(t.objectStore("meta").getAllKeys()),
    );
    expect(metaKeys.map(String).sort()).toEqual(["seq", "trajectory:t-new"]);
    const eventKeys = await tx(db, ["events"], "readonly", (t) =>
      requestToPromise(t.objectStore("events").getAllKeys()),
    );
    expect(eventKeys).toEqual([["t-new", 1]]);
    db.close();
  });

  test("creates exactly the outbox's two stores with the documented key paths", async () => {
    const db = await openRecorderDatabase(freshName());
    expect([...db.objectStoreNames].sort()).toEqual(["events", "meta"]);
    expect([...STORES].sort()).toEqual(["events", "meta"]);
    expect(keyPathOf(db, "events")).toEqual(["trajectoryId", "seq"]);
    expect(keyPathOf(db, "meta")).toBeNull();
    db.close();
  });

  test("opening twice upgrades once", async () => {
    const name = freshName();
    const first = await openRecorderDatabase(name);
    await tx(first, ["meta"], "readwrite", (t) =>
      requestToPromise(t.objectStore("meta").put("kept", "marker")),
    );
    const second = await openRecorderDatabase(name);
    expect(second.version).toBe(2);
    const value = await tx(second, ["meta"], "readonly", (t) =>
      requestToPromise(t.objectStore("meta").get("marker")),
    );
    expect(value).toBe("kept");
    first.close();
    second.close();
  });

  test("tx resolves the work's value and rejects when the work throws", async () => {
    const db = await openRecorderDatabase(freshName());
    const value = await tx(db, ["meta"], "readwrite", async (t) => {
      await requestToPromise(t.objectStore("meta").put(7, "n"));
      return requestToPromise(t.objectStore("meta").get("n"));
    });
    expect(value).toBe(7);
    await expect(
      tx(db, ["meta"], "readwrite", () => {
        throw new Error("boom");
      }),
    ).rejects.toThrow("boom");
    db.close();
  });

  test("tx waits for work that awaits something other than IndexedDB", async () => {
    const db = await openRecorderDatabase(freshName());
    const value = await tx(db, ["meta"], "readwrite", async () => {
      await new Promise((resolve) => setTimeout(resolve, 20));
      return "v";
    });
    expect(value).toBe("v");
    db.close();
  });

  test("tx rejects when work touches the transaction after it has finished", async () => {
    const db = await openRecorderDatabase(freshName());
    await expect(
      tx(db, ["meta"], "readwrite", async (t) => {
        await new Promise((resolve) => setTimeout(resolve, 20));
        t.objectStore("meta").put("late", "k");
      }),
    ).rejects.toThrow();
    const stored = await tx(db, ["meta"], "readonly", (t) =>
      requestToPromise(t.objectStore("meta").get("k")),
    );
    expect(stored).toBeUndefined();
    db.close();
  });

  test("tx rejects with the failing request's error when work does not await it", async () => {
    const db = await openRecorderDatabase(freshName());
    await tx(db, ["events"], "readwrite", (t) =>
      requestToPromise(
        t.objectStore("events").add({ trajectoryId: "t", seq: 0 }),
      ),
    );
    const error = await tx(db, ["events"], "readwrite", (t) => {
      t.objectStore("events").add({ trajectoryId: "t", seq: 0 });
      return "ok";
    }).then(
      () => undefined,
      (e: unknown) => e,
    );
    expect((error as Error | undefined)?.name).toBe("ConstraintError");
    db.close();
  });

  test("tx resolves when the caller handled a request error", async () => {
    const db = await openRecorderDatabase(freshName());
    await tx(db, ["events"], "readwrite", (t) => {
      t.objectStore("events").add({ trajectoryId: "t", seq: 0 });
    });
    await tx(db, ["events"], "readwrite", (t) => {
      const duplicate = t
        .objectStore("events")
        .add({ trajectoryId: "t", seq: 0 });
      duplicate.onerror = (e) => e.preventDefault();
      t.objectStore("events").put({ trajectoryId: "t", seq: 1 });
    });
    const count = await tx(db, ["events"], "readonly", (t) =>
      requestToPromise(t.objectStore("events").count()),
    );
    expect(count).toBe(2);
    db.close();
  });
});