cojson 0.13.16 → 0.13.17

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

@@ -45,6 +45,53 @@ describe("loading coValues from server", () => {
     `);
   });
 
+  test("unavailable coValue retry", async () => {
+    const client = setupTestNode();
+    const client2 = setupTestNode();
+
+    client2.connectToSyncServer({
+      ourName: "client2",
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const promise = loadCoValueOrFail(client2.node, map.id);
+
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    client.connectToSyncServer();
+
+    const mapOnClient2 = await promise;
+
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client2 -> server | LOAD Map sessions: empty",
+        "server -> client2 | KNOWN Map sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/1",
+        "server -> client | KNOWN Group sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/1",
+        "server -> client2 | CONTENT Group header: true new: After: 0 New: 3",
+        "client2 -> server | KNOWN Group sessions: header/3",
+        "server -> client2 | CONTENT Map header: true new: After: 0 New: 1",
+        "client2 -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
   test("coValue with parent groups loading", async () => {
     const client = setupTestNode({
       connected: true,
@@ -327,5 +374,35 @@ describe("loading coValues from server", () => {
     `);
   });
 
-  test.todo("should mark the coValue as unavailable if the peer is closed");
+  test("should mark the coValue as unavailable if the peer is closed", async () => {
+    const client = setupTestNode();
+    const { peerState } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const map = group.createMap({
+      test: "value",
+    });
+
+    const promise = client.node.load(map.id);
+
+    // Close the peer connection
+    peerState.gracefulShutdown();
+
+    expect(await promise).toEqual("unavailable");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+  });
 });

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

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
+  blockMessageTypeOnOutgoingPeer,
   loadCoValueOrFail,
   setupTestNode,
   waitFor,
@@ -322,4 +323,70 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       ]
     `);
   });
+
+  test("load returns the coValue as soon as one of the peers return the content", async () => {
+    const client = setupTestNode();
+    const coreServer = setupTestNode({
+      isSyncServer: true,
+    });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServerName: "core",
+    });
+
+    const storage = setupTestNode();
+
+    const { peer: storagePeer } = client.connectToSyncServer({
+      syncServerName: "storage",
+      syncServer: storage.node,
+    });
+
+    storagePeer.priority = 100;
+
+    const group = coreServer.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    const { peerState } = storage.connectToSyncServer({
+      ourName: "storage-of-client",
+      syncServerName: "core",
+    });
+
+    await loadCoValueOrFail(storage.node, map.id);
+
+    peerState.gracefulShutdown();
+
+    SyncMessagesLog.clear();
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    map.set("hello", "updated", "trusting");
+
+    // Block the content message from the core peer to simulate the delay on response
+    blockMessageTypeOnOutgoingPeer(peerOnServer, "content");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | KNOWN Group sessions: header/3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> core | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | KNOWN Map sessions: header/1",
+        "core -> client | KNOWN Group sessions: header/3",
+        "client -> core | LOAD Map sessions: header/1",
+        "client -> core | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+
+    expect(mapOnClient.get("hello")).toEqual("world");
+  });
 });