jazz-tools 0.15.8 → 0.15.10

package/src/tools/tests/load.test.ts

@@ -1,5 +1,6 @@
-import { cojsonInternals } from "cojson";
-import { beforeEach, expect, test } from "vitest";
+import { waitFor } from "@testing-library/dom";
+import { cojsonInternals, emptyKnownState } from "cojson";
+import { assert, beforeEach, expect, test } from "vitest";
 import { Account, Group, co, z } from "../exports.js";
 import {
   createJazzTestAccount,
@@ -7,6 +8,8 @@ import {
   setupJazzTestSync,
 } from "../testing.js";
 
+cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 10;
+
 beforeEach(async () => {
   await setupJazzTestSync();
   await createJazzTestAccount({
@@ -48,20 +51,9 @@ test("retry an unavailable value", async () => {
 
   const alice = await createJazzTestAccount();
 
-  let resolved = false;
   const promise = Person.load(map.id, { loadAs: alice });
-  promise.then(() => {
-    resolved = true;
-  });
-
-  await new Promise((resolve) =>
-    setTimeout(
-      resolve,
-      cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY - 100,
-    ),
-  );
 
-  expect(resolved).toBe(false);
+  await new Promise((resolve) => setTimeout(resolve));
 
   // Reconnect the current account
   currentAccount._raw.core.node.syncManager.addPeer(
@@ -69,7 +61,6 @@ test("retry an unavailable value", async () => {
   );
 
   const john = await promise;
-  expect(resolved).toBe(true);
   expect(john).not.toBeNull();
   expect(john?.name).toBe("John");
 });
@@ -92,26 +83,70 @@ test("returns null if the value is unavailable after retries", async () => {
 
   const alice = await createJazzTestAccount();
 
-  let resolved = false;
-  const promise = Person.load(map.id, { loadAs: alice });
-  promise.then(() => {
-    resolved = true;
+  const john = await Person.load(map.id, { loadAs: alice });
+
+  expect(john).toBeNull();
+});
+
+test("load a large coValue", async () => {
+  const syncServer = await setupJazzTestSync({ asyncPeers: true });
+
+  const LargeDataset = co.map({
+    metadata: z.object({
+      name: z.string(),
+      description: z.string(),
+      createdAt: z.number(),
+    }),
+    data: co.list(z.string()),
   });
 
-  await new Promise((resolve) =>
-    setTimeout(
-      resolve,
-      cojsonInternals.CO_VALUE_LOADING_CONFIG.RETRY_DELAY + 100,
-    ),
+  const group = Group.create(syncServer);
+  const largeMap = LargeDataset.create(
+    {
+      metadata: {
+        name: "Large Dataset",
+        description:
+          "A dataset with many entries for testing large coValue loading",
+        createdAt: Date.now(),
+      },
+      data: LargeDataset.def.shape.data.create([], group),
+    },
+    group,
   );
+  group.addMember("everyone", "reader");
 
-  expect(resolved).toBe(true);
+  const dataSize = 100 * 1024;
+  const chunkSize = 1024;
+  const chunks = dataSize / chunkSize;
 
-  // Reconnect the current account
-  currentAccount._raw.core.node.syncManager.addPeer(
-    getPeerConnectedToTestSyncServer(),
+  const value = "x".repeat(chunkSize);
+
+  for (let i = 0; i < chunks; i++) {
+    largeMap.data.push(value);
+  }
+
+  // Wait for the large coValue to be fully synced
+  await largeMap.data._raw.core.waitForSync();
+
+  const alice = await createJazzTestAccount();
+
+  // Test loading the large coValue
+  const loadedDataset = await LargeDataset.load(largeMap.id, {
+    loadAs: alice,
+    resolve: {
+      data: true,
+    },
+  });
+
+  assert(loadedDataset);
+
+  expect(loadedDataset.metadata.name).toBe("Large Dataset");
+  expect(loadedDataset.metadata.description).toBe(
+    "A dataset with many entries for testing large coValue loading",
   );
 
-  const john = await promise;
-  expect(john).toBeNull();
+  expect(loadedDataset.data.length).toBe(chunks);
+  expect(loadedDataset.data._raw.core.knownState()).toEqual(
+    largeMap.data._raw.core.knownState(),
+  );
 });

package/src/tools/tests/subscribe.test.ts

@@ -1198,6 +1198,98 @@ describe("subscribeToCoValue", () => {
     expect(onUnavailable).not.toHaveBeenCalled();
     expect(onUnauthorized).not.toHaveBeenCalled();
   });
+
+  it("should subscribe to a large coValue", async () => {
+    const syncServer = await setupJazzTestSync({ asyncPeers: true });
+
+    const LargeDataset = co.map({
+      metadata: z.object({
+        name: z.string(),
+        description: z.string(),
+        createdAt: z.number(),
+      }),
+      data: co.list(z.string()),
+    });
+
+    const group = Group.create(syncServer);
+    const largeMap = LargeDataset.create(
+      {
+        metadata: {
+          name: "Large Dataset",
+          description:
+            "A dataset with many entries for testing large coValue subscription",
+          createdAt: Date.now(),
+        },
+        data: LargeDataset.def.shape.data.create([], group),
+      },
+      group,
+    );
+    group.addMember("everyone", "reader");
+
+    const dataSize = 100 * 1024;
+    const chunkSize = 1024;
+    const chunks = dataSize / chunkSize;
+
+    const value = "x".repeat(chunkSize);
+
+    for (let i = 0; i < chunks; i++) {
+      largeMap.data.push(value);
+    }
+
+    // Wait for the large coValue to be fully synced
+    await largeMap.data._raw.core.waitForSync();
+
+    const alice = await createJazzTestAccount();
+
+    let result = null as Loaded<typeof LargeDataset, { data: true }> | null;
+    const updateFn = vi.fn().mockImplementation((value) => {
+      result = value;
+    });
+
+    // Test subscribing to the large coValue
+    const unsubscribe = subscribeToCoValue(
+      zodSchemaToCoSchema(LargeDataset),
+      largeMap.id,
+      {
+        loadAs: alice,
+        resolve: {
+          data: true,
+        },
+      },
+      updateFn,
+    );
+
+    onTestFinished(unsubscribe);
+
+    await waitFor(() => {
+      expect(updateFn).toHaveBeenCalled();
+    });
+
+    assert(result);
+
+    expect(updateFn).toHaveBeenCalledTimes(1);
+    expect(result.metadata.name).toBe("Large Dataset");
+    expect(result.metadata.description).toBe(
+      "A dataset with many entries for testing large coValue subscription",
+    );
+
+    expect(result.data.length).toBe(chunks);
+    expect(result.data._raw.core.knownState()).toEqual(
+      largeMap.data._raw.core.knownState(),
+    );
+
+    // Test that updates to the large coValue are properly subscribed
+    updateFn.mockClear();
+    largeMap.data.push("new entry");
+
+    await waitFor(() => {
+      expect(updateFn).toHaveBeenCalled();
+    });
+
+    expect(updateFn).toHaveBeenCalledTimes(1);
+    expect(result.data.length).toBe(chunks + 1);
+    expect(result.data[chunks]).toBe("new entry");
+  });
 });
 
 describe("createCoValueObservable", () => {