cojson 0.14.25 → 0.14.27

package/src/tests/coValueCoreLoadingState.test.ts

@@ -195,7 +195,7 @@ describe("CoValueCore loading state", () => {
         role: "storage",
       },
       async () => {
-        state.markAvailable({} as CoValueHeader, "peer1");
+        state.provideHeader({} as CoValueHeader, "peer1");
       },
     );
     const peer2 = createMockPeerState(
@@ -248,7 +248,7 @@ describe("CoValueCore loading state", () => {
         role: "server",
       },
       async () => {
-        state.markAvailable({} as CoValueHeader, "peer2");
+        state.provideHeader({} as CoValueHeader, "peer2");
       },
     );
 

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

@@ -1,16 +1,22 @@
-import { beforeEach, describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 
 import { expectMap } from "../coValue";
-import { toSimplifiedMessages } from "./messagesTestUtils";
+import { CO_VALUE_LOADING_CONFIG } from "../coValueCore/coValueCore";
+import { RawCoMap } from "../exports";
 import {
   SyncMessagesLog,
+  blockMessageTypeOnOutgoingPeer,
   loadCoValueOrFail,
+  setupTestAccount,
   setupTestNode,
   waitFor,
 } from "./testUtils";
 
 let jazzCloud = setupTestNode({ isSyncServer: true });
 
+// Set a short timeout to make the tests on unavailable complete faster
+CO_VALUE_LOADING_CONFIG.RETRY_DELAY = 100;
+
 beforeEach(async () => {
   SyncMessagesLog.clear();
   jazzCloud = setupTestNode({ isSyncServer: true });
@@ -406,4 +412,334 @@ describe("loading coValues from server", () => {
       ]
     `);
   });
+
+  test("coValue with a delayed group loading", async () => {
+    const client = setupTestNode();
+
+    const { peerOnServer } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    const parentGroup = jazzCloud.node.createGroup();
+    parentGroup.addMember("everyone", "reader");
+
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: group.id,
+      once: true,
+    });
+
+    group.extend(parentGroup);
+
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        ParentGroup: parentGroup.core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT ParentGroup header: true new: After: 0 New: 6",
+        "client -> server | KNOWN ParentGroup sessions: header/6",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | LOAD Group sessions: empty",
+        "client -> server | KNOWN Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | KNOWN Group sessions: header/5",
+      ]
+    `);
+
+    blocker.unblock();
+  });
+
+  test("coValue with a delayed parent group loading", async () => {
+    const client = setupTestNode();
+
+    const { peerOnServer } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    const parentGroup = jazzCloud.node.createGroup();
+    parentGroup.addMember("everyone", "reader");
+
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: parentGroup.id,
+      once: true,
+    });
+
+    group.extend(parentGroup);
+
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        ParentGroup: parentGroup.core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | LOAD ParentGroup sessions: empty",
+        "client -> server | KNOWN Group sessions: empty",
+        "server -> client | CONTENT ParentGroup header: true new: After: 0 New: 6",
+        "client -> server | KNOWN ParentGroup sessions: header/6",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+
+    blocker.unblock();
+  });
+
+  test("coValue with a delayed account loading (block once)", async () => {
+    const client = setupTestNode();
+    const syncServer = await setupTestAccount({ isSyncServer: true });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServer: syncServer.node,
+    });
+
+    const group = syncServer.node.createGroup();
+    group.addMember("everyone", "writer");
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: syncServer.accountID,
+      once: true,
+    });
+
+    const account = syncServer.node.expectCurrentAccount(syncServer.accountID);
+
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+
+    // ParentGroup sent twice, once because the server pushed it and another time because the client requested the missing dependency
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | LOAD Account sessions: empty",
+        "client -> server | KNOWN Group sessions: empty",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Account sessions: header/4",
+        "client -> server | KNOWN Group sessions: header/5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+
+    blocker.unblock();
+  });
+
+  test("coValue with a delayed account loading related to an update (block once)", async () => {
+    const client = setupTestNode();
+    const user = await setupTestAccount({
+      connected: true,
+    });
+
+    const { peerOnServer } = client.connectToSyncServer();
+
+    const account = user.node.expectCurrentAccount(user.accountID);
+    await user.node.syncManager.waitForAllCoValuesSync();
+
+    SyncMessagesLog.clear();
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: user.accountID,
+      once: true,
+    });
+
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    const mapOnUser = await loadCoValueOrFail(user.node, map.id);
+    mapOnUser.set("user", true);
+
+    await mapOnUser.core.waitForSync();
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("user")).toEqual(true);
+
+    // ParentGroup sent twice, once because the server pushed it and another time because the client requested the missing dependency
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | KNOWN Group sessions: header/5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Map sessions: header/1",
+        "client -> server | CONTENT Map header: false new: After: 0 New: 1",
+        "server -> client | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | KNOWN Group sessions: header/5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1 | After: 0 New: 1",
+        "client -> server | LOAD Account sessions: empty",
+        "client -> server | KNOWN Map sessions: empty",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Account sessions: header/4",
+        "client -> server | KNOWN Map sessions: header/2",
+      ]
+    `);
+
+    blocker.unblock();
+  });
+
+  test("coValue with a delayed account loading (block for 100ms)", async () => {
+    const client = setupTestNode();
+    const syncServer = await setupTestAccount({ isSyncServer: true });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServer: syncServer.node,
+    });
+
+    const group = syncServer.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: syncServer.accountID,
+    });
+
+    const account = syncServer.node.expectCurrentAccount(syncServer.accountID);
+
+    const map = group.createMap();
+    map.set("hello", "world");
+
+    const core = client.node.getCoValue(map.id);
+    const promise = client.node.loadCoValueCore(map.id);
+
+    const spy = vi.fn();
+
+    core.subscribe(spy);
+    spy.mockClear(); // Reset the first call
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    blocker.sendBlockedMessages();
+    blocker.unblock();
+
+    await promise;
+
+    expect(spy).toHaveBeenCalled();
+    expect(core.isAvailable()).toBe(true);
+
+    const mapOnClient = expectMap(core.getCurrentContent());
+    expect(mapOnClient.get("hello")).toEqual("world");
+
+    // Account sent twice, once because the server pushed it and another time because the client requested the missing dependency
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "client -> server | LOAD Account sessions: empty",
+        "client -> server | KNOWN Group sessions: empty",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Map sessions: empty",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Account sessions: header/4",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Group sessions: header/5",
+      ]
+    `);
+  });
+
+  test("coValue with a delayed account loading with no group (block for 100ms)", async () => {
+    const client = setupTestNode();
+    const syncServer = await setupTestAccount({ isSyncServer: true });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServer: syncServer.node,
+    });
+
+    const blocker = blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {
+      id: syncServer.accountID,
+    });
+
+    const account = syncServer.node.expectCurrentAccount(syncServer.accountID);
+
+    const map = syncServer.node
+      .createCoValue({
+        type: "comap",
+        ruleset: {
+          type: "ownedByGroup",
+          group: syncServer.accountID,
+        },
+        meta: null,
+        ...syncServer.node.crypto.createdNowUnique(),
+      })
+      .getCurrentContent() as RawCoMap;
+
+    map.set("hello", "world", "trusting");
+
+    const core = client.node.getCoValue(map.id);
+    const promise = client.node.loadCoValueCore(map.id);
+
+    const spy = vi.fn();
+
+    core.subscribe(spy);
+    spy.mockClear(); // Reset the first call
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    blocker.sendBlockedMessages();
+    blocker.unblock();
+
+    await promise;
+
+    expect(spy).toHaveBeenCalled();
+    expect(core.isAvailable()).toBe(true);
+
+    const mapOnClient = expectMap(core.getCurrentContent());
+    expect(mapOnClient.get("hello")).toEqual("world");
+
+    // Account sent twice, once because the server pushed it and another time because the client requested the missing dependency
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: account.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | LOAD Account sessions: empty",
+        "client -> server | KNOWN Map sessions: empty",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Account sessions: header/4",
+        "server -> client | CONTENT Account header: true new: After: 0 New: 4",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
 });

package/src/tests/sync.mesh.test.ts

@@ -380,7 +380,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
     map.set("hello", "updated", "trusting");
 
     // Block the content message from the core peer to simulate the delay on response
-    blockMessageTypeOnOutgoingPeer(peerOnServer, "content");
+    blockMessageTypeOnOutgoingPeer(peerOnServer, "content", {});
 
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
 
@@ -431,7 +431,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       },
     });
 
-    blockMessageTypeOnOutgoingPeer(peerToCoreServer, "load");
+    blockMessageTypeOnOutgoingPeer(peerToCoreServer, "load", {});
 
     client.node.syncManager.addPeer(peer1);
     anotherServer.node.syncManager.addPeer(peer2);

package/src/tests/sync.peerReconciliation.test.ts

@@ -1,9 +1,10 @@
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue";
+import { CO_VALUE_LOADING_CONFIG } from "../coValueCore/coValueCore";
 import { WasmCrypto } from "../crypto/WasmCrypto";
+import { RawCoMap } from "../exports";
 import {
   SyncMessagesLog,
-  loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
   waitFor,
@@ -195,10 +196,8 @@ describe("peer reconciliation", () => {
         "client -> server | CONTENT Map header: true new: After: 0 New: 2",
         "server -> client | LOAD Group sessions: empty",
         "client -> server | CONTENT Group header: true new: After: 0 New: 3",
-        "server -> client | KNOWN CORRECTION Map sessions: empty",
-        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Map sessions: empty",
         "server -> client | KNOWN Group sessions: header/3",
-        "server -> client | KNOWN Map sessions: header/2",
         "client -> server | LOAD Group sessions: header/3",
         "server -> client | KNOWN Group sessions: header/3",
         "client -> server | LOAD Map sessions: header/2",
@@ -232,7 +231,9 @@ describe("peer reconciliation", () => {
     await waitFor(() => {
       const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
 
-      expect(mapOnSyncServer.loadingState).toBe("available");
+      expect(mapOnSyncServer.isAvailable()).toBe(true);
+      const content = mapOnSyncServer.getCurrentContent() as RawCoMap;
+      expect(content.get("hello")).toBe("updated");
     });
 
     expect(
@@ -263,11 +264,10 @@ describe("peer reconciliation", () => {
         "client -> server | CONTENT Account header: true new: After: 0 New: 4",
         "server -> client | LOAD Group sessions: empty",
         "client -> server | CONTENT Group header: true new: After: 0 New: 3",
-        "server -> client | KNOWN CORRECTION Map sessions: empty",
-        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Map sessions: empty",
         "server -> client | KNOWN Account sessions: header/4",
+        "server -> client | KNOWN Map sessions: empty",
         "server -> client | KNOWN Group sessions: header/3",
-        "server -> client | KNOWN Map sessions: header/2",
         "client -> server | LOAD Account sessions: header/4",
         "server -> client | KNOWN Account sessions: header/4",
         "client -> server | LOAD ProfileGroup sessions: header/5",

package/src/tests/sync.test.ts

@@ -601,7 +601,7 @@ describe("SyncManager - knownStates vs optimisticKnownStates", () => {
     // optimisticKnownStates is updated when the content messages are sent,
     // while knownStates is only updated when we receive the "known" messages
     // that are acknowledging the receipt of the content messages
-    const outgoing = blockMessageTypeOnOutgoingPeer(peer, "content");
+    const outgoing = blockMessageTypeOnOutgoingPeer(peer, "content", {});
 
     map.set("key2", "value2", "trusting");
 

package/src/tests/testUtils.ts

@@ -287,15 +287,25 @@ export async function loadCoValueOrFail<V extends RawCoValue>(
 export function blockMessageTypeOnOutgoingPeer(
   peer: Peer,
   messageType: SyncMessage["action"],
+  opts: {
+    id?: string;
+    once?: boolean;
+  },
 ) {
   const push = peer.outgoing.push;
   const pushSpy = vi.spyOn(peer.outgoing, "push");
 
   const blockedMessages: SyncMessage[] = [];
+  const blockedIds = new Set<string>();
 
   pushSpy.mockImplementation(async (msg) => {
-    if (msg.action === messageType) {
+    if (
+      msg.action === messageType &&
+      (!opts.id || msg.id === opts.id) &&
+      (!opts.once || !blockedIds.has(msg.id))
+    ) {
       blockedMessages.push(msg);
+      blockedIds.add(msg.id);
       return Promise.resolve();
     }