cojson 0.8.32 → 0.8.35

package/src/tests/sync.test.ts

@@ -1437,6 +1437,7 @@ describe("sync - extra tests", () => {
     const reasonableMemoryUsage = 1; // 500 MB
     expect(memoryUsage).toBeLessThan(reasonableMemoryUsage);
   });
+
   test("Node correctly handles and recovers from network partitions", async () => {
     // Create three nodes
     const [admin1, session1] = randomAnonymousAccountAndSessionID();
@@ -1872,6 +1873,34 @@ describe("SyncManager.addPeer", () => {
     expect(closeSpy).not.toHaveBeenCalled();
     expect(firstPeer.closed).toBe(true);
   });
+
+  test("when adding a server peer the local coValues should be sent to it", async () => {
+    // Setup nodes
+    const client = createTestNode();
+    const jazzCloud = createTestNode();
+
+    // Connect nodes initially
+    const [connectionWithClientAsPeer, jazzCloudConnectionAsPeer] =
+      connectedPeers("connectionWithClient", "jazzCloudConnection", {
+        peer1role: "client",
+        peer2role: "server",
+      });
+
+    jazzCloud.syncManager.addPeer(connectionWithClientAsPeer);
+
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    client.syncManager.addPeer(jazzCloudConnectionAsPeer);
+
+    await client.syncManager.waitForUploadIntoPeer(
+      jazzCloudConnectionAsPeer.id,
+      map.core.id,
+    );
+
+    expect(jazzCloud.coValuesStore.get(map.id).state.type).toBe("available");
+  });
 });
 
 describe("loadCoValueCore with retry", () => {

package/src/tests/testUtils.ts

@@ -1,8 +1,11 @@
 import { expect } from "vitest";
 import { ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { CoID, RawCoValue } from "../exports.js";
 import { SessionID } from "../ids.js";
 import { LocalNode } from "../localNode.js";
+import { connectedPeers } from "../streamUtils.js";
+import { Peer } from "../sync.js";
 import { expectGroup } from "../typeUtils/expectGroup.js";
 
 const Crypto = await WasmCrypto.create();
@@ -23,6 +26,93 @@ export function createTestNode() {
   return new LocalNode(admin, session, Crypto);
 }
 
+export function createTwoConnectedNodes(
+  node1Role: Peer["role"],
+  node2Role: Peer["role"],
+) {
+  // Setup nodes
+  const node1 = createTestNode();
+  const node2 = createTestNode();
+
+  // Connect nodes initially
+  const [node1ToNode2Peer, node2ToNode1Peer] = connectedPeers(
+    "node1ToNode2",
+    "node2ToNode1",
+    {
+      peer1role: node2Role,
+      peer2role: node1Role,
+    },
+  );
+
+  node1.syncManager.addPeer(node1ToNode2Peer);
+  node2.syncManager.addPeer(node2ToNode1Peer);
+
+  return {
+    node1,
+    node2,
+    node1ToNode2Peer,
+    node2ToNode1Peer,
+  };
+}
+
+export function createThreeConnectedNodes(
+  node1Role: Peer["role"],
+  node2Role: Peer["role"],
+  node3Role: Peer["role"],
+) {
+  // Setup nodes
+  const node1 = createTestNode();
+  const node2 = createTestNode();
+  const node3 = createTestNode();
+
+  // Connect nodes initially
+  const [node1ToNode2Peer, node2ToNode1Peer] = connectedPeers(
+    "node1ToNode2",
+    "node2ToNode1",
+    {
+      peer1role: node2Role,
+      peer2role: node1Role,
+    },
+  );
+
+  const [node1ToNode3Peer, node3ToNode1Peer] = connectedPeers(
+    "node1ToNode3",
+    "node3ToNode1",
+    {
+      peer1role: node3Role,
+      peer2role: node1Role,
+    },
+  );
+
+  const [node2ToNode3Peer, node3ToNode2Peer] = connectedPeers(
+    "node2ToNode3",
+    "node3ToNode2",
+    {
+      peer1role: node3Role,
+      peer2role: node2Role,
+    },
+  );
+
+  node1.syncManager.addPeer(node1ToNode2Peer);
+  node1.syncManager.addPeer(node1ToNode3Peer);
+  node2.syncManager.addPeer(node2ToNode1Peer);
+  node2.syncManager.addPeer(node2ToNode3Peer);
+  node3.syncManager.addPeer(node3ToNode1Peer);
+  node3.syncManager.addPeer(node3ToNode2Peer);
+
+  return {
+    node1,
+    node2,
+    node3,
+    node1ToNode2Peer,
+    node2ToNode1Peer,
+    node1ToNode3Peer,
+    node3ToNode1Peer,
+    node2ToNode3Peer,
+    node3ToNode2Peer,
+  };
+}
+
 export function newGroup() {
   const [admin, sessionID] = randomAnonymousAccountAndSessionID();
 
@@ -58,7 +148,7 @@ export function groupWithTwoAdmins() {
   }
 
   expect(group.get(otherAdmin.id)).toEqual("admin");
-  return { groupCore, admin, otherAdmin, node };
+  return { group, groupCore, admin, otherAdmin, node };
 }
 
 export function newGroupHighLevel() {
@@ -126,3 +216,14 @@ export function waitFor(callback: () => boolean | void) {
     }, 100);
   });
 }
+
+export async function loadCoValueOrFail<V extends RawCoValue>(
+  node: LocalNode,
+  id: CoID<V>,
+): Promise<V> {
+  const value = await node.load(id);
+  if (value === "unavailable") {
+    throw new Error("CoValue not found");
+  }
+  return value;
+}