cojson 0.18.6 → 0.18.8

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",
       ]
     `);
@@ -1134,4 +1134,21 @@ describe("loading coValues from server", () => {
     const mapOnServerCore = await syncServer.node.loadCoValueCore(map.core.id);
     expect(mapOnServerCore.isAvailable()).toBe(true);
   });
+
+  test("unknown coValues are ignored if ignoreUnrequestedCoValues is true", async () => {
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const { node: shardedCoreNode } = setupTestNode({
+      connected: true,
+    });
+    shardedCoreNode.syncManager.disableTransactionVerification();
+    shardedCoreNode.syncManager.ignoreUnknownCoValuesFromServers();
+
+    await shardedCoreNode.loadCoValueCore(map.id);
+
+    expect(shardedCoreNode.hasCoValue(map.id)).toBe(true);
+    expect(shardedCoreNode.hasCoValue(group.id)).toBe(false);
+  });
 });

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.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",
       ]
     `);