cojson 0.19.22 → 0.20.0

package/dist/tests/StorageApiSync.test.js

@@ -1,14 +1,8 @@
-import { randomUUID } from "node:crypto";
-import { unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, onTestFinished, test, vi } from "vitest";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
-import { LocalNode, logger } from "../exports.js";
+import { describe, expect, test, vi, afterEach } from "vitest";
+import { logger } from "../exports.js";
 import { emptyKnownState } from "../knownState.js";
-import { createSyncStorage } from "./testStorage.js";
-import { loadCoValueOrFail, randomAgentAndSessionID } from "./testUtils.js";
-const crypto = await WasmCrypto.create();
+import { createSyncStorage, getAllCoValuesWaitingForDelete, getCoValueStoredSessions, getDbPath, } from "./testStorage.js";
+import { fillCoMapWithLargeData, loadCoValueOrFail, setupTestNode, } from "./testUtils.js";
 /**
  * Helper function that gets new content since a known state, throwing if:
  * - The coValue is not verified
@@ -24,53 +18,33 @@ function getNewContentSince(coValue, knownState) {
     }
     return contentMessage;
 }
-async function createFixturesNode(customDbPath) {
-    const [admin, session] = randomAgentAndSessionID();
-    const node = new LocalNode(admin.agentSecret, session, crypto);
-    // Create a unique database file for each test
-    const dbPath = customDbPath ?? join(tmpdir(), `test-${randomUUID()}.db`);
-    const storage = createSyncStorage({
-        filename: dbPath,
-        nodeName: "test",
-        storageName: "test-storage",
-    });
-    onTestFinished(() => {
-        try {
-            unlinkSync(dbPath);
-        }
-        catch { }
-    });
-    node.setStorage(storage);
-    return {
-        fixturesNode: node,
-        dbPath,
-    };
-}
-async function createTestNode(dbPath) {
-    const [admin, session] = randomAgentAndSessionID();
-    const node = new LocalNode(admin.agentSecret, session, crypto);
-    const storage = createSyncStorage({
-        filename: dbPath,
-        nodeName: "test",
-        storageName: "test-storage",
-    });
-    return {
-        node,
-        storage,
-    };
-}
+afterEach(() => {
+    vi.useRealTimers();
+});
 describe("StorageApiSync", () => {
     describe("getKnownState", () => {
         test("should return empty known state for new coValue ID and cache the result", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const id = fixturesNode.createGroup().id;
+            const fixtures = setupTestNode();
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const id = fixtures.node.createGroup().id;
             const knownState = storage.getKnownState(id);
             expect(knownState).toEqual(emptyKnownState(id));
             expect(storage.getKnownState(id)).toBe(knownState); // Should return same instance
         });
         test("should return separate known state instances for different coValue IDs", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             const id1 = "test-id-1";
             const id2 = "test-id-2";
             const knownState1 = storage.getKnownState(id1);
@@ -80,7 +54,13 @@ describe("StorageApiSync", () => {
     });
     describe("load", () => {
         test("should fail gracefully when loading non-existent coValue and preserve known state", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             const id = "non-existent-id";
             const callback = vi.fn();
             const done = vi.fn();
@@ -95,12 +75,27 @@ describe("StorageApiSync", () => {
             expect(afterLoadKnownState).toEqual(initialKnownState);
         });
         test("should successfully load coValue with header and update known state", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Create a real group and get its content message
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             await group.core.waitForSync();
             // Get initial known state
             const initialKnownState = storage.getKnownState(group.id);
@@ -115,16 +110,31 @@ describe("StorageApiSync", () => {
             // Verify that storage known state is updated after load
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.core.verified.header).toEqual(group.core.verified.header);
         });
         test("should successfully load coValue with transactions and update known state", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Create a real group and add a member to create transactions
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Get initial known state
@@ -135,23 +145,35 @@ describe("StorageApiSync", () => {
                 id: group.id,
                 header: group.core.verified.header,
                 new: expect.objectContaining({
-                    [fixturesNode.currentSessionID]: expect.any(Object),
+                    [fixtures.node.currentSessionID]: expect.any(Object),
                 }),
             }));
             expect(done).toHaveBeenCalledWith(true);
             // Verify that storage known state is updated after load
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
     });
     describe("store", () => {
         test("should successfully store new coValue with header and update known state", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a real group and get its content message
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
             const correctionCallback = vi.fn();
             // Get initial known state
@@ -161,15 +183,27 @@ describe("StorageApiSync", () => {
             // Verify that storage known state is updated after store
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.core.verified.header).toEqual(group.core.verified.header);
         });
         test("should successfully store coValue with transactions and update known state", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a real group and add a member to create transactions
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
             const correctionCallback = vi.fn();
@@ -180,14 +214,26 @@ describe("StorageApiSync", () => {
             // Verify that storage known state is updated after store
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
         test("should handle correction when header assumption is invalid", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "reader");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -204,14 +250,26 @@ describe("StorageApiSync", () => {
             // Verify that storage known state is updated after store with correction
             const updatedKnownState = storage.getKnownState(group.id);
             expect(updatedKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("reader");
         });
         test("should handle correction when new content assumption is invalid", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { node, storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = fixtures.node.createGroup();
             const initialContent = getNewContentSince(group.core, emptyKnownState(group.id));
             const initialKnownState = group.core.knownState();
             group.addMember("everyone", "reader");
@@ -235,14 +293,26 @@ describe("StorageApiSync", () => {
             // Verify that storage known state is updated after store with correction
             const finalKnownState = storage.getKnownState(group.id);
             expect(finalKnownState).toEqual(group.core.knownState());
-            node.setStorage(storage);
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            client.addStorage({ storage });
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             expect(groupOnNode.get("everyone")).toEqual("writer");
         });
         test("should log error and fail when correction callback returns undefined", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "writer");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -265,9 +335,21 @@ describe("StorageApiSync", () => {
             errorSpy.mockClear();
         });
         test("should log error and fail when correction callback returns invalid content message", async () => {
-            const { fixturesNode } = await createFixturesNode();
-            const { storage } = await createTestNode();
-            const group = fixturesNode.createGroup();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = fixtures.node.createGroup();
             const knownState = group.core.knownState();
             group.addMember("everyone", "writer");
             const contentMessage = getNewContentSince(group.core, knownState);
@@ -288,14 +370,35 @@ describe("StorageApiSync", () => {
             errorSpy.mockClear();
         });
         test("should successfully store coValue with multiple sessions", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { fixturesNode: fixtureNode2 } = await createFixturesNode(dbPath);
-            const { node, storage } = await createTestNode();
-            const coValue = fixturesNode.createCoValue({
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const fixture2 = setupTestNode();
+            fixture2.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const coValue = fixtures.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...fixtures.node.crypto.createdNowUnique(),
             });
             coValue.makeTransaction([
                 {
@@ -303,7 +406,7 @@ describe("StorageApiSync", () => {
                 },
             ], "trusting");
             await coValue.waitForSync();
-            const mapOnNode2 = await loadCoValueOrFail(fixtureNode2, coValue.id);
+            const mapOnNode2 = await loadCoValueOrFail(fixture2.node, coValue.id);
             coValue.makeTransaction([
                 {
                     count: 2,
@@ -313,22 +416,164 @@ describe("StorageApiSync", () => {
             const contentMessage = getNewContentSince(mapOnNode2.core, emptyKnownState(mapOnNode2.id));
             const correctionCallback = vi.fn();
             storage.store(contentMessage, correctionCallback);
-            node.setStorage(storage);
-            const finalMap = await loadCoValueOrFail(node, mapOnNode2.id);
+            client.addStorage({ storage });
+            const finalMap = await loadCoValueOrFail(client.node, mapOnNode2.id);
             expect(finalMap.core.knownState()).toEqual(knownState);
         });
     });
+    describe("delete flow", () => {
+        test("deleteCoValue enqueues the coValue for erasure", async () => {
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = client.node.createGroup();
+            const map = group.createMap();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            const queued = await getAllCoValuesWaitingForDelete(storage);
+            expect(queued).toContain(map.id);
+        });
+        test("background erasure doesn't run if not enabled", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = node.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            vi.useFakeTimers();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            await vi.advanceTimersByTimeAsync(70000);
+            // Queue drained
+            expect(await getAllCoValuesWaitingForDelete(storage)).toContain(map.id);
+        });
+        test("background erasure run if enabled", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = node.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            vi.useFakeTimers();
+            node.node.enableDeletedCoValuesErasure();
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            await vi.advanceTimersByTimeAsync(70000);
+            // Queue drained
+            expect(await getAllCoValuesWaitingForDelete(storage)).not.toContain(map.id);
+            const sessionIDs = await getCoValueStoredSessions(storage, map.id);
+            expect(sessionIDs).toHaveLength(1);
+            expect(sessionIDs[0]).toMatch(/_session_d[1-9A-HJ-NP-Za-km-z]+\$$/); // Delete session format
+        });
+        test("eraseAllDeletedCoValues deletes history but preserves tombstone", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const { storage } = node.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            map.set("k", "v");
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            expect(await getAllCoValuesWaitingForDelete(storage)).toContain(map.id);
+            await storage.eraseAllDeletedCoValues();
+            // Queue drained
+            expect(await getAllCoValuesWaitingForDelete(storage)).not.toContain(map.id);
+            // Tombstone preserved + history erased when loaded from storage
+            const client = setupTestNode();
+            const { storage: clientStorage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const loaded = await loadCoValueOrFail(client.node, map.id);
+            expect(loaded.core.isDeleted).toBe(true);
+            expect(loaded.get("k")).toBeUndefined();
+            const sessionIDs = await getCoValueStoredSessions(clientStorage, map.id);
+            expect(sessionIDs).toHaveLength(1);
+            expect(sessionIDs[0]).toMatch(/_session_d[1-9A-HJ-NP-Za-km-z]+\$$/); // Delete session format
+        });
+        test("eraseAllDeletedCoValues does not break when called while a coValue is streaming from storage", async () => {
+            const dbPath = getDbPath();
+            const node = setupTestNode();
+            const storage = createSyncStorage({
+                filename: dbPath,
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            node.addStorage({ storage });
+            const group = node.node.createGroup();
+            const map = group.createMap();
+            fillCoMapWithLargeData(map);
+            await map.core.waitForSync();
+            map.core.deleteCoValue();
+            await map.core.waitForSync();
+            storage.close();
+            const newStorage = createSyncStorage({
+                filename: dbPath,
+                nodeName: "test",
+                storageName: "test-storage",
+            });
+            const callback = vi.fn();
+            const loadPromise = new Promise((resolve) => {
+                newStorage.load(map.id, callback, resolve);
+            });
+            await newStorage.eraseAllDeletedCoValues();
+            expect(await loadPromise).toBe(true);
+        });
+    });
     describe("dependencies", () => {
         test("should load dependencies before dependent coValues and update all known states", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group and a map owned by that group to create dependencies
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Get initial known states
             const initialGroupKnownState = storage.getKnownState(group.id);
@@ -350,20 +595,35 @@ describe("StorageApiSync", () => {
             const updatedMapKnownState = storage.getKnownState(map.id);
             expect(updatedGroupKnownState).toEqual(group.core.knownState());
             expect(updatedMapKnownState).toEqual(map.core.knownState());
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
         test("should skip loading already loaded dependencies", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group and a map owned by that group
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Get initial known states
             const initialGroupKnownState = storage.getKnownState(group.id);
@@ -388,20 +648,35 @@ describe("StorageApiSync", () => {
             // Verify map known state is updated after second load
             const finalMapKnownState = storage.getKnownState(map.id);
             expect(finalMapKnownState).toEqual(map.core.knownState());
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
         test("should load dependencies again if they were unmounted", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group and a map owned by that group
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             const map = group.createMap({ test: "value" });
             await group.core.waitForSync();
             await map.core.waitForSync();
-            const callback = vi.fn((content) => node.syncManager.handleNewContent(content, "storage"));
+            const callback = vi.fn((content) => client.node.syncManager.handleNewContent(content, "storage"));
             const done = vi.fn();
             // Load the map (and its group)
             await storage.load(map.id, callback, done);
@@ -420,26 +695,41 @@ describe("StorageApiSync", () => {
                 id: map.id,
             }));
             expect(done).toHaveBeenCalledWith(true);
-            node.setStorage(storage);
-            const mapOnNode = await loadCoValueOrFail(node, map.id);
+            client.addStorage({ storage });
+            const mapOnNode = await loadCoValueOrFail(client.node, map.id);
             expect(mapOnNode.get("test")).toEqual("value");
         });
     });
     describe("waitForSync", () => {
         test("should resolve immediately when coValue is already synced", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { node, storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group and add a member
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // Store the group in storage
             const contentMessage = getNewContentSince(group.core, emptyKnownState(group.id));
             const correctionCallback = vi.fn();
             storage.store(contentMessage, correctionCallback);
-            node.setStorage(storage);
+            client.addStorage({ storage });
             // Load the group on the new node
-            const groupOnNode = await loadCoValueOrFail(node, group.id);
+            const groupOnNode = await loadCoValueOrFail(client.node, group.id);
             // Wait for sync should resolve immediately since the coValue is already synced
             await expect(storage.waitForSync(group.id, groupOnNode.core)).resolves.toBeUndefined();
             expect(groupOnNode.get("everyone")).toEqual("reader");
@@ -447,16 +737,37 @@ describe("StorageApiSync", () => {
     });
     describe("close", () => {
         test("should close storage without throwing errors", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             expect(() => storage.close()).not.toThrow();
         });
     });
     describe("loadKnownState", () => {
         test("should return correct knownState structure for existing CoValue", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group to have data in the database
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             const result = await new Promise((resolve) => {
@@ -468,21 +779,42 @@ describe("StorageApiSync", () => {
             expect(result?.sessions).toEqual(group.core.knownState().sessions);
         });
         test("should return undefined for non-existent CoValue", async () => {
-            const { storage } = await createTestNode();
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             const result = await new Promise((resolve) => {
                 storage.loadKnownState("co_nonexistent", resolve);
             });
             expect(result).toBeUndefined();
         });
         test("should handle CoValue with no sessions (header only)", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a CoValue with just a header (no transactions yet)
-            const coValue = fixturesNode.createCoValue({
+            const coValue = fixtures.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...fixtures.node.crypto.createdNowUnique(),
             });
             await coValue.waitForSync();
             const result = await new Promise((resolve) => {
@@ -495,19 +827,41 @@ describe("StorageApiSync", () => {
             expect(Object.keys(result?.sessions || {}).length).toBe(0);
         });
         test("should handle CoValue with multiple sessions", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { fixturesNode: fixturesNode2 } = await createFixturesNode(dbPath);
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const fixtures2 = setupTestNode();
+            fixtures2.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a CoValue and have two nodes make transactions
-            const coValue = fixturesNode.createCoValue({
+            const coValue = fixtures.node.createCoValue({
                 type: "comap",
                 ruleset: { type: "unsafeAllowAll" },
                 meta: null,
-                ...crypto.createdNowUnique(),
+                ...fixtures.node.crypto.createdNowUnique(),
             });
             coValue.makeTransaction([{ key1: "value1" }], "trusting");
             await coValue.waitForSync();
-            const coValueOnNode2 = await loadCoValueOrFail(fixturesNode2, coValue.id);
+            const coValueOnNode2 = await loadCoValueOrFail(fixtures2.node, coValue.id);
             coValueOnNode2.set("key2", "value2", "trusting");
             await coValueOnNode2.core.waitForSync();
             const result = await new Promise((resolve) => {
@@ -522,10 +876,25 @@ describe("StorageApiSync", () => {
             expect(result?.sessions).toEqual(coValueOnNode2.core.knownState().sessions);
         });
         test("should use cache when knownState is cached", async () => {
-            const { fixturesNode, dbPath } = await createFixturesNode();
-            const { storage } = await createTestNode(dbPath);
+            const dbPath = getDbPath();
+            const fixtures = setupTestNode();
+            fixtures.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
+            const client = setupTestNode();
+            const { storage } = client.addStorage({
+                storage: createSyncStorage({
+                    filename: dbPath,
+                    nodeName: "test",
+                    storageName: "test-storage",
+                }),
+            });
             // Create a group to have data in the database
-            const group = fixturesNode.createGroup();
+            const group = fixtures.node.createGroup();
             group.addMember("everyone", "reader");
             await group.core.waitForSync();
             // First call should hit the database and cache the result