cojson 0.18.5 → 0.18.7

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

@@ -0,0 +1,153 @@
+import { beforeEach, describe, expect, test } from "vitest";
+
+import { SyncMessagesLog, TEST_NODE_CONFIG, setupTestNode } from "./testUtils";
+
+// We want to simulate a real world communication that happens asynchronously
+TEST_NODE_CONFIG.withAsyncPeers = true;
+
+describe("handling content messages", () => {
+  beforeEach(async () => {
+    SyncMessagesLog.clear();
+  });
+
+  test("dependencies are included when syncing new content to clients", async () => {
+    /*
+     * Initial Setup:
+     * core <-- edge <-- client1
+     */
+    const core = setupTestNode();
+
+    const edge = setupTestNode();
+    edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core",
+      syncServer: core.node,
+    });
+
+    const client1 = setupTestNode();
+    client1.connectToSyncServer({
+      ourName: "client1",
+      syncServerName: "edge",
+      syncServer: edge.node,
+    });
+
+    // Create a map with a dependency on the client.
+    // Everythig will sync all the way back to core.
+    const group = client1.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+    await map.core.waitForSync();
+
+    /*
+     * Add another client:
+     *
+     *                  |-- client1
+     * core <-- edge <--|
+     *                  |-- client2
+     *
+     */
+    const client2 = setupTestNode();
+    const { peerStateOnServer: client2PeerStateOnEdge } =
+      client2.connectToSyncServer({
+        ourName: "client2",
+        syncServerName: "edge",
+        syncServer: edge.node,
+      });
+
+    client2PeerStateOnEdge.setOptimisticKnownState(map.core.id, {
+      id: map.core.id,
+      header: false,
+      sessions: {},
+    });
+
+    // Update the map on client1.
+    // This should sync the map AND its dependencies to the new client.
+    map.set("hello2", "world2", "trusting");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> client2 | CONTENT Map"),
+      ),
+    ).toBe(true);
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> client2 | CONTENT Group"),
+      ),
+    ).toBe(true);
+  });
+
+  test("dependencies are excluded when syncing new content to servers", async () => {
+    /*
+     * Initial Setup:
+     * core1 <-- edge <-- client
+     */
+    const core1 = setupTestNode();
+
+    const edge = setupTestNode();
+    edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core1",
+      syncServer: core1.node,
+    });
+
+    const client = setupTestNode();
+    client.connectToSyncServer({
+      ourName: "client",
+      syncServerName: "edge",
+      syncServer: edge.node,
+    });
+
+    // Create a map with a dependency on the client.
+    // Everythig will sync all the way back to core1.
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+    await map.core.waitForSync();
+
+    /*
+     * Add another core:
+     *
+     * core1 <--
+     *         |
+     *         |-- edge <-- client
+     *         |
+     * core2 <--
+     */
+    const core2 = setupTestNode();
+    const { peerState: core2PeerStateOnEdge } = edge.connectToSyncServer({
+      ourName: "edge",
+      syncServerName: "core2",
+      syncServer: core2.node,
+      skipReconciliation: true,
+    });
+
+    core2PeerStateOnEdge.setOptimisticKnownState(map.core.id, {
+      id: map.core.id,
+      header: false,
+      sessions: {},
+    });
+
+    // Update the map on the client.
+    // This should sync ONLY the map back to both cores.
+    map.set("hello2", "world2", "trusting");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some((msg) => msg.startsWith("edge -> core2 | CONTENT Map")),
+    ).toBe(true);
+    expect(
+      syncMessages.some((msg) =>
+        msg.startsWith("edge -> core2 | CONTENT Group"),
+      ),
+    ).toBe(false);
+  });
+});

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

@@ -171,10 +171,10 @@ describe("loading coValues from server", () => {
       [
         "client -> server | LOAD Branch sessions: empty",
         "server -> client | CONTENT Group header: true new: After: 0 New: 5",
-        "server -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 3",
         "server -> client | CONTENT Branch header: true new: After: 0 New: 2",
         "client -> server | KNOWN Group sessions: header/5",
-        "client -> server | KNOWN Map sessions: header/2",
+        "client -> server | KNOWN Map sessions: header/3",
         "client -> server | KNOWN Branch sessions: header/2",
       ]
     `);
@@ -507,9 +507,9 @@ describe("loading coValues from server", () => {
       connected: true,
     });
 
-    await loadCoValueOrFail(client.node, largeMap.id);
+    const mapOnClient = await loadCoValueOrFail(client.node, largeMap.id);
 
-    await largeMap.core.waitForSync();
+    await mapOnClient.core.waitForFullStreaming();
 
     expect(
       SyncMessagesLog.getMessages({

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

@@ -238,7 +238,7 @@ describe("client with storage syncs with server", () => {
       [
         "client -> storage | LOAD Branch sessions: empty",
         "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
-        "storage -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 3",
         "storage -> client | CONTENT Branch header: true new: After: 0 New: 2",
       ]
     `);

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

@@ -14,12 +14,15 @@ import { getDbPath } from "./testStorage";
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
 
+beforeEach(async () => {
+  setMaxRecommendedTxSize(100 * 1024);
+});
+
 describe("client with storage syncs with server", () => {
   let jazzCloud: ReturnType<typeof setupTestNode>;
 
   beforeEach(async () => {
     vi.resetAllMocks();
-    setMaxRecommendedTxSize(100 * 1024);
     SyncMessagesLog.clear();
     jazzCloud = setupTestNode({
       isSyncServer: true,
@@ -434,6 +437,8 @@ describe("client syncs with a server with storage", () => {
   });
 
   test("large coValue streaming from cold server", async () => {
+    setMaxRecommendedTxSize(1000);
+
     const server = setupTestNode({
       isSyncServer: true,
     });
@@ -470,8 +475,6 @@ describe("client syncs with a server with storage", () => {
 
     await largeMap.core.waitForSync();
 
-    SyncMessagesLog.clear();
-
     server.restart();
 
     server.addStorage({
@@ -491,9 +494,10 @@ describe("client syncs with a server with storage", () => {
       storage,
     });
 
-    const mapOnClient2 = await loadCoValueOrFail(client.node, largeMap.id);
+    SyncMessagesLog.clear();
 
-    await mapOnClient2.core.waitForSync();
+    const mapOnClient2 = await loadCoValueOrFail(client.node, largeMap.id);
+    await mapOnClient2.core.waitForFullStreaming();
 
     expect(
       SyncMessagesLog.getMessages({
@@ -516,13 +520,6 @@ describe("client syncs with a server with storage", () => {
         "storage -> client | CONTENT Map header: true new: After: 7 New: 1",
         "storage -> client | CONTENT Map header: true new: After: 8 New: 1",
         "storage -> client | CONTENT Map header: true new: After: 9 New: 1",
-        "storage -> client | CONTENT Map header: true new: After: 10 New: 0",
-        "server -> storage | LOAD Group sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
-        "server -> client | KNOWN Group sessions: header/5",
-        "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Map header: true new: After: 0 New: 1 expectContentUntil: header/10",
-        "server -> client | KNOWN Map sessions: header/10",
       ]
     `);
   });

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

@@ -92,11 +92,11 @@ describe("client to server upload", () => {
         "server -> client | CONTENT Map header: true new: After: 0 New: 2",
         "client -> server | KNOWN Group sessions: header/5",
         "client -> server | KNOWN Map sessions: header/2",
-        "client -> server | LOAD Branch sessions: empty",
-        "server -> client | KNOWN Branch sessions: empty",
         "client -> server | CONTENT Branch header: true new: After: 0 New: 1",
+        "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "client -> server | CONTENT Branch header: false new: After: 1 New: 1",
         "server -> client | KNOWN Branch sessions: header/1",
+        "server -> client | KNOWN Map sessions: header/3",
         "server -> client | KNOWN Branch sessions: header/2",
       ]
     `);