cojson 0.17.11 → 0.17.13

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

@@ -0,0 +1,119 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { setCoValueLoadingRetryDelay } from "../config";
+import {
+  SyncMessagesLog,
+  TEST_NODE_CONFIG,
+  blockMessageTypeOnOutgoingPeer,
+  connectedPeersWithMessagesTracking,
+  getSyncServerConnectedPeer,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+} from "./testUtils";
+import { Peer } from "../exports";
+import { ServerPeerSelector } from "../sync";
+
+beforeEach(async () => {
+  // We want to simulate a real world communication that happens asynchronously
+  TEST_NODE_CONFIG.withAsyncPeers = true;
+
+  SyncMessagesLog.clear();
+});
+
+describe("sharding", () => {
+  test("server peers are not filtered by default", async () => {
+    const { node: client } = setupTestNode({
+      connected: false,
+    });
+    const group = client.createGroup();
+
+    const allPeers: Peer[] = [];
+    for (let i = 0; i < 5; i++) {
+      const syncServer = await setupTestAccount({ isSyncServer: true });
+
+      const { peer } = getSyncServerConnectedPeer({
+        peerId: client.getCurrentAgent().id,
+        syncServer: syncServer.node,
+      });
+
+      client.syncManager.addPeer(peer);
+      allPeers.push(peer);
+    }
+
+    const serverPeers = client.syncManager.getServerPeers(group.id);
+    expect(serverPeers.map((p) => p.id)).toEqual(allPeers.map((p) => p.id));
+  });
+
+  test("server peers are filtered when a serverPeerSelector is set", async () => {
+    const firstAlphabetical: ServerPeerSelector = (id, serverPeers) => {
+      return serverPeers.sort((a, b) => a.id.localeCompare(b.id)).slice(0, 1);
+    };
+    const { node: client } = setupTestNode({
+      connected: false,
+    });
+    client.syncManager.serverPeerSelector = firstAlphabetical;
+    const group = client.createGroup();
+
+    const allPeers: Peer[] = [];
+    for (let i = 0; i < 5; i++) {
+      const syncServer = await setupTestAccount({ isSyncServer: true });
+
+      const { peer } = getSyncServerConnectedPeer({
+        peerId: client.getCurrentAgent().id,
+        syncServer: syncServer.node,
+      });
+
+      client.syncManager.addPeer(peer);
+      allPeers.push(peer);
+    }
+
+    const serverPeers = client.syncManager.getServerPeers(group.id);
+    expect(serverPeers.length).toBe(1);
+    expect(serverPeers[0]!.id).toEqual(
+      allPeers.sort((a, b) => a.id.localeCompare(b.id))[0]!.id,
+    );
+  });
+
+  test("getPeers respects the serverPeerSelector", async () => {
+    const firstPeer: ServerPeerSelector = (id, serverPeers) => {
+      return serverPeers.slice(0, 1);
+    };
+    const { node: edge } = setupTestNode({
+      connected: false,
+    });
+    edge.syncManager.serverPeerSelector = firstPeer;
+
+    // Connect 2 clients to edge
+    for (let i = 0; i < 2; i++) {
+      const client = await setupTestAccount({});
+      const { peer1, peer2 } = connectedPeersWithMessagesTracking({
+        peer1: {
+          id: client.node.getCurrentAgent().id,
+          role: "client",
+        },
+        peer2: {
+          id: edge.getCurrentAgent().id,
+          role: "server",
+        },
+      });
+
+      edge.syncManager.addPeer(peer1);
+    }
+
+    // Connect edge to 3 core nodes
+    for (let i = 0; i < 3; i++) {
+      const syncServer = await setupTestAccount({ isSyncServer: true });
+
+      const { peer } = getSyncServerConnectedPeer({
+        peerId: edge.getCurrentAgent().id,
+        syncServer: syncServer.node,
+      });
+
+      edge.syncManager.addPeer(peer);
+    }
+
+    expect(edge.syncManager.getPeers("co_z12345").length).toBe(
+      2 + 1, // 2 clients + 1 selected core
+    );
+  });
+});

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

@@ -20,6 +20,7 @@ import {
   waitFor,
 } from "./testUtils";
 import { stableStringify } from "../jsonStringify";
+import { determineValidTransactions } from "../permissions";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -151,6 +152,47 @@ describe("client with storage syncs with server", () => {
     `);
   });
 
+  test("persists meta information", async () => {
+    const client = setupTestNode();
+
+    const { storage } = client.addStorage();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.core.makeTransaction([], "trusting", {
+      meta: true,
+    });
+
+    await map.core.waitForSync();
+
+    client.restart();
+
+    client.addStorage({
+      storage,
+    });
+
+    const loadedValue = await loadCoValueOrFail(client.node, map.id);
+
+    const validTransactions = determineValidTransactions(loadedValue.core);
+
+    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+  });
+
   test("updating a coValue while offline", async () => {
     const client = setupTestNode();
 
@@ -164,7 +206,7 @@ describe("client with storage syncs with server", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
-    client.node.syncManager.getPeers()[0]?.gracefulShutdown();
+    client.node.syncManager.getPeers(map.id)[0]?.gracefulShutdown();
 
     SyncMessagesLog.clear();
     map.set("hello", "updated", "trusting");

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

@@ -156,7 +156,7 @@ describe("client with storage syncs with server", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
-    client.node.syncManager.getPeers()[0]?.gracefulShutdown();
+    client.node.syncManager.getPeers(map.id)[0]?.gracefulShutdown();
 
     SyncMessagesLog.clear();
     map.set("hello", "updated", "trusting");

package/src/tests/sync.test.ts

@@ -599,8 +599,12 @@ describe("SyncManager - knownStates vs optimisticKnownStates", () => {
     // Wait for the full sync to complete
     await mapOnClient.core.waitForSync();
 
-    const peerStateClient = client.syncManager.getPeers()[0]!;
-    const peerStateJazzCloud = jazzCloud.node.syncManager.getPeers()[0]!;
+    const peerStateClient = client.syncManager.getPeers(
+      mapOnClient.core.id,
+    )[0]!;
+    const peerStateJazzCloud = jazzCloud.node.syncManager.getPeers(
+      mapOnClient.core.id,
+    )[0]!;
 
     // The optimisticKnownStates should be the same as the knownStates after the full sync is complete
     expect(
@@ -1115,3 +1119,46 @@ describe("SyncManager.handleSyncMessage", () => {
     expect(peerState.knownStates.has(group.id)).toBe(true);
   });
 });
+
+describe("SyncManager.trackDirtyCoValues", () => {
+  test("should track the dirty coValues", async () => {
+    const node = createTestNode();
+
+    const tracking = node.syncManager.trackDirtyCoValues();
+
+    const group = node.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    const trackedValues = tracking.done();
+    expect(trackedValues.size).toBe(2);
+    expect(trackedValues.has(map.id)).toBe(true);
+    expect(trackedValues.has(group.id)).toBe(true);
+  });
+
+  test("should track the dirty coValues only when active", async () => {
+    const node = createTestNode();
+
+    const group = node.createGroup();
+
+    const tracking1 = node.syncManager.trackDirtyCoValues();
+
+    const map1 = group.createMap();
+    map1.set("key1", "value1", "trusting");
+
+    const tracking2 = node.syncManager.trackDirtyCoValues();
+
+    const map2 = group.createMap();
+    map2.set("key2", "value2", "trusting");
+
+    const tracked1 = tracking1.done();
+
+    const map3 = group.createMap();
+    map3.set("key3", "value3", "trusting");
+
+    const tracked2 = tracking2.done();
+
+    expect(Array.from(tracked1)).toEqual([map1.id, map2.id]);
+    expect(Array.from(tracked2)).toEqual([map2.id, map3.id]);
+  });
+});

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

@@ -9,6 +9,7 @@ import {
   setupTestNode,
   waitFor,
 } from "./testUtils";
+import { determineValidTransactions } from "../permissions";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -51,6 +52,40 @@ describe("client to server upload", () => {
     `);
   });
 
+  test("syncs meta information", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.core.makeTransaction([], "trusting", {
+      meta: true,
+    });
+
+    await map.core.waitForSync();
+
+    const loadedValue = await loadCoValueOrFail(jazzCloud.node, map.id);
+
+    const validTransactions = determineValidTransactions(loadedValue.core);
+
+    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "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",
+      ]
+    `);
+  });
+
   test("coValue with parent groups uploading", async () => {
     const client = setupTestNode({
       connected: true,

package/src/tests/testUtils.ts

@@ -669,9 +669,11 @@ export async function setupTestAccount(
     addStorage,
     addAsyncStorage,
     disconnect: () => {
-      ctx.node.syncManager.getPeers().forEach((peer) => {
+      const allPeers = ctx.node.syncManager.getPeers(ctx.accountID);
+      allPeers.forEach((peer) => {
         peer.gracefulShutdown();
       });
+      ctx.node.syncManager.peers = {};
     },
   };
 }