cojson 0.17.10 → 0.17.12

package/src/tests/group.addMember.test.ts

@@ -2,7 +2,6 @@ import { beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
 import {
   SyncMessagesLog,
-  TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
@@ -220,68 +219,75 @@ describe("Group.addMember", () => {
     expect(personOnReaderNode.get("name")).toEqual(undefined);
   });
 
-  test("an admin should not be able downgrade an admin", async () => {
-    const admin = await setupTestAccount({
-      connected: true,
-    });
-
-    const otherAdmin = await setupTestAccount({
-      connected: true,
-    });
-
-    const group = admin.node.createGroup();
-    const person = group.createMap({
-      name: "John Doe",
-    });
-
-    const otherAdminOnAdminNode = await loadCoValueOrFail(
-      admin.node,
-      otherAdmin.accountID,
-    );
-    group.addMember(otherAdminOnAdminNode, "admin");
-
-    // Try to downgrade other admin
-    try {
-      group.addMember(otherAdminOnAdminNode, "writer");
-    } catch (e) {
-      expect(e).toBeDefined();
-    }
-
-    expect(group.roleOf(otherAdmin.accountID)).toEqual("admin");
-
-    // Verify other admin still has admin access by adding a new member
-    const reader = await setupTestAccount({
-      connected: true,
-    });
-
-    const readerOnOtherAdminNode = await loadCoValueOrFail(
-      otherAdmin.node,
-      reader.accountID,
-    );
-    group.addMember(readerOnOtherAdminNode, "reader");
-
-    const personOnReaderNode = await loadCoValueOrFail(reader.node, person.id);
-
-    await waitFor(() => {
-      expect(
-        expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
-      ).toEqual("John Doe");
-    });
-  });
-
-  test("an admin should be able downgrade themselves", async () => {
-    const admin = await setupTestAccount({
-      connected: true,
-    });
-
-    const group = admin.node.createGroup();
-
-    const account = await loadCoValueOrFail(admin.node, admin.accountID);
-
-    // Downgrade self to writer
-    group.addMember(account, "writer");
-    expect(group.roleOf(admin.accountID)).toEqual("writer");
-  });
+  test.each(["writer", "reader", "writeOnly"] as const)(
+    "an admin should not be able to downgrade an admin to %s",
+    async (targetRole) => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const otherAdmin = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+      const person = group.createMap({
+        name: "John Doe",
+      });
+
+      const otherAdminOnAdminNode = await loadCoValueOrFail(
+        admin.node,
+        otherAdmin.accountID,
+      );
+      group.addMember(otherAdminOnAdminNode, "admin");
+
+      // Try to downgrade other admin
+      expect(() => group.addMember(otherAdminOnAdminNode, targetRole)).toThrow(
+        "Administrators cannot demote other administrators in a group",
+      );
+
+      expect(group.roleOf(otherAdmin.accountID)).toEqual("admin");
+
+      // Verify other admin still has admin access by adding a new member
+      const reader = await setupTestAccount({
+        connected: true,
+      });
+
+      const readerOnOtherAdminNode = await loadCoValueOrFail(
+        otherAdmin.node,
+        reader.accountID,
+      );
+      group.addMember(readerOnOtherAdminNode, "reader");
+
+      const personOnReaderNode = await loadCoValueOrFail(
+        reader.node,
+        person.id,
+      );
+
+      await waitFor(() => {
+        expect(
+          expectMap(personOnReaderNode.core.getCurrentContent()).get("name"),
+        ).toEqual("John Doe");
+      });
+    },
+  );
+
+  test.each(["writer", "reader", "writeOnly"] as const)(
+    "an admin should be able downgrade themselves to %s",
+    async (targetRole) => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+
+      const account = await loadCoValueOrFail(admin.node, admin.accountID);
+
+      // Downgrade self to target role
+      group.addMember(account, targetRole);
+      expect(group.roleOf(admin.accountID)).toEqual(targetRole);
+    },
+  );
 
   test("an admin should be able downgrade a writeOnly to reader", async () => {
     const admin = await setupTestAccount({

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

@@ -0,0 +1,109 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { setCoValueLoadingRetryDelay } from "../config";
+import {
+  SyncMessagesLog,
+  TEST_NODE_CONFIG,
+  blockMessageTypeOnOutgoingPeer,
+  getSyncServerConnectedPeer,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+} from "./testUtils";
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+// Set a short timeout to make the tests on unavailable complete faster
+setCoValueLoadingRetryDelay(100);
+
+beforeEach(async () => {
+  // We want to simulate a real world communication that happens asynchronously
+  TEST_NODE_CONFIG.withAsyncPeers = true;
+
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("sending known coValues", () => {
+  test("dependencies are included when responding to a client", async () => {
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const { node: client } = setupTestNode({
+      connected: true,
+    });
+
+    map.set("hello2", "world2", "trusting");
+    await map.core.waitForSync();
+
+    const mapOnClient = await loadCoValueOrFail(client, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+    expect(mapOnClient.get("hello2")).toEqual("world2");
+
+    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: 3",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "client -> server | KNOWN Group sessions: header/3",
+        "client -> server | KNOWN Map sessions: header/2",
+      ]
+    `);
+  });
+
+  test("dependencies are excluded when responding to a server", async () => {
+    // Create a disconnected client
+    const { node: client, accountID } = await setupTestAccount({
+      connected: false,
+    });
+    const account = client.expectCurrentAccount(accountID);
+
+    // Prepare a group -- this will be a non-account dependency of a forthcoming map.
+    const group = client.createGroup();
+    group.addMember("everyone", "writer");
+
+    // Let the queue drain
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    // Disable transaction verification on the server so it doesn't ask for dependencies.
+    jazzCloud.node.syncManager.disableTransactionVerification();
+
+    // Connect the client, but don't setup syncing just yet...
+    const { peer } = getSyncServerConnectedPeer({
+      peerId: client.getCurrentAgent().id,
+      syncServer: jazzCloud.node,
+    });
+
+    // Disable reconciliation while we setup syncing because we don't want the
+    // server to know about our forthcoming map's dependencies (group + account).
+    const blocker = blockMessageTypeOnOutgoingPeer(peer, "load", {});
+    client.syncManager.addPeer(peer);
+    blocker.unblock();
+
+    // Create a map and set a value on it, this will trigger:
+    //   - CONTENT from client to server
+    //   - KNOWN from server to client
+    //
+    // We don't expect any more messages to be sent from client to server in this
+    // case because clients shouldn't greedily send dependencies to a server.
+    const map = group.createMap();
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Account: account.core,
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some(
+        (msg) =>
+          msg.includes("CONTENT Account") || msg.includes("CONTENT Group"),
+      ),
+    ).toBe(false);
+  });
+});

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

@@ -9,6 +9,7 @@ import {
   SyncMessagesLog,
   TEST_NODE_CONFIG,
   blockMessageTypeOnOutgoingPeer,
+  getSyncServerConnectedPeer,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
@@ -1034,4 +1035,55 @@ describe("loading coValues from server", () => {
 
     vi.useRealTimers();
   });
+
+  test("should not request dependencies if transaction verification is disabled", async () => {
+    // Create a disconnected client
+    const { node: client, accountID } = await setupTestAccount({
+      connected: false,
+    });
+    const account = client.expectCurrentAccount(accountID);
+
+    // Prepare a group -- this will be a non-account dependency of a forthcoming map.
+    const group = client.createGroup();
+    group.addMember("everyone", "writer");
+
+    // Create a sync server and disable transaction verification
+    const syncServer = await setupTestAccount({ isSyncServer: true });
+    syncServer.node.syncManager.disableTransactionVerification();
+
+    // Connect the client, but don't setup syncing just yet...
+    const { peer } = getSyncServerConnectedPeer({
+      peerId: client.getCurrentAgent().id,
+      syncServer: syncServer.node,
+    });
+
+    // Disable reconciliation while we setup syncing because we don't want the
+    // server to know about our forthcoming map's dependencies (group + account).
+    const blocker = blockMessageTypeOnOutgoingPeer(peer, "load", {});
+    client.syncManager.addPeer(peer);
+    blocker.unblock();
+
+    // Create a map and set a value on it.
+    // If transaction verification were enabled, this would trigger LOAD messages
+    // from the server to the client asking for the group and account. However, we
+    // don't expect to see those messages since we disabled transaction verification.
+    const map = group.createMap();
+    map.set("hello", "world");
+    await map.core.waitForSync();
+
+    const syncMessages = SyncMessagesLog.getMessages({
+      Account: account.core,
+      Group: group.core,
+      Map: map.core,
+    });
+    expect(
+      syncMessages.some(
+        (msg) => msg.includes("LOAD Account") || msg.includes("LOAD Group"),
+      ),
+    ).toBe(false);
+
+    // Verify the map is available on the server (transaction was accepted)
+    const mapOnServerCore = await syncServer.node.loadCoValueCore(map.core.id);
+    expect(mapOnServerCore.isAvailable()).toBe(true);
+  });
 });

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

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { setCoValueLoadingRetryDelay } from "../config";
+import {
+  SyncMessagesLog,
+  TEST_NODE_CONFIG,
+  blockMessageTypeOnOutgoingPeer,
+  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,
+    );
+  });
+});

package/src/tests/sync.test.ts

@@ -180,9 +180,7 @@ test("should not verify transactions when SyncManager has verification disabled"
         madeAt: Date.now(),
       },
     ],
-    undefined,
     Crypto.sign(agent.currentSignerSecret(), "hash_z12345678"),
-    "immediate",
     true,
   );
 
@@ -1117,3 +1115,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]);
+  });
+});