cojson 0.13.25 → 0.13.28

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

@@ -0,0 +1,255 @@
+import { beforeEach, describe, expect, test } from "vitest";
+import { RawCoList } from "../coValues/coList.js";
+import { RawCoMap } from "../coValues/coMap.js";
+import { RawCoStream } from "../coValues/coStream.js";
+import { RawBinaryCoStream } from "../coValues/coStream.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
+import { RawAccountID } from "../exports.js";
+import {
+  SyncMessagesLog,
+  createTwoConnectedNodes,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+} from "./testUtils.js";
+
+let jazzCloud = setupTestNode({ isSyncServer: true });
+
+beforeEach(async () => {
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
+});
+
+describe("Group.removeMember", () => {
+  test("a reader member should be able to revoke themselves", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const readerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      reader.accountID,
+    );
+    group.addMember(readerOnAdminNode, "reader");
+
+    const groupOnReaderNode = await loadCoValueOrFail(reader.node, group.id);
+    expect(groupOnReaderNode.myRole()).toEqual("reader");
+
+    await groupOnReaderNode.removeMember(
+      reader.node.expectCurrentAccount("reader"),
+    );
+
+    expect(groupOnReaderNode.myRole()).toEqual(undefined);
+  });
+
+  test("a writer member should be able to revoke themselves", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writer = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writer.accountID,
+    );
+    group.addMember(writerOnAdminNode, "writer");
+
+    const groupOnWriterNode = await loadCoValueOrFail(writer.node, group.id);
+    expect(groupOnWriterNode.myRole()).toEqual("writer");
+
+    await groupOnWriterNode.removeMember(
+      writer.node.expectCurrentAccount("writer"),
+    );
+
+    expect(groupOnWriterNode.myRole()).toEqual(undefined);
+  });
+
+  test("a writeOnly member should be able to revoke themselves", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writeOnly = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writeOnlyOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writeOnly.accountID,
+    );
+    group.addMember(writeOnlyOnAdminNode, "writeOnly");
+
+    const groupOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnly.node,
+      group.id,
+    );
+    expect(groupOnWriteOnlyNode.myRole()).toEqual("writeOnly");
+
+    await groupOnWriteOnlyNode.removeMember(
+      writeOnly.node.expectCurrentAccount("writeOnly"),
+    );
+
+    expect(groupOnWriteOnlyNode.myRole()).toEqual(undefined);
+  });
+
+  test("an admin member should be able to revoke themselves", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherAdmin = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const otherAdminOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherAdmin.accountID,
+    );
+    group.addMember(otherAdminOnAdminNode, "admin");
+
+    const groupOnOtherAdminNode = await loadCoValueOrFail(
+      otherAdmin.node,
+      group.id,
+    );
+    expect(groupOnOtherAdminNode.myRole()).toEqual("admin");
+
+    await groupOnOtherAdminNode.removeMember(
+      otherAdmin.node.expectCurrentAccount("admin"),
+    );
+
+    expect(groupOnOtherAdminNode.myRole()).toEqual(undefined);
+  });
+
+  test("a writer member cannot remove other accounts", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writer = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherMember = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writer.accountID,
+    );
+    const otherMemberOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherMember.accountID,
+    );
+
+    group.addMember(writerOnAdminNode, "writer");
+    group.addMember(otherMemberOnAdminNode, "reader");
+
+    const groupOnWriterNode = await loadCoValueOrFail(writer.node, group.id);
+    expect(groupOnWriterNode.myRole()).toEqual("writer");
+
+    const otherMemberOnWriterNode = await loadCoValueOrFail(
+      writer.node,
+      otherMember.accountID,
+    );
+
+    await groupOnWriterNode.removeMember(otherMemberOnWriterNode);
+
+    expect(groupOnWriterNode.roleOf(otherMember.accountID)).toEqual("reader");
+  });
+
+  test("a writeOnly member cannot remove other accounts", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const writeOnly = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherMember = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const writeOnlyOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      writeOnly.accountID,
+    );
+    const otherMemberOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherMember.accountID,
+    );
+
+    group.addMember(writeOnlyOnAdminNode, "writeOnly");
+    group.addMember(otherMemberOnAdminNode, "reader");
+
+    const groupOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnly.node,
+      group.id,
+    );
+    expect(groupOnWriteOnlyNode.myRole()).toEqual("writeOnly");
+
+    const otherMemberOnWriteOnlyNode = await loadCoValueOrFail(
+      writeOnly.node,
+      otherMember.accountID,
+    );
+
+    await groupOnWriteOnlyNode.removeMember(otherMemberOnWriteOnlyNode);
+
+    expect(groupOnWriteOnlyNode.roleOf(otherMember.accountID)).toEqual(
+      "reader",
+    );
+  });
+
+  test("a reader member cannot remove other accounts", async () => {
+    const admin = await setupTestAccount({
+      connected: true,
+    });
+
+    const reader = await setupTestAccount({
+      connected: true,
+    });
+
+    const otherMember = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = admin.node.createGroup();
+    const readerOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      reader.accountID,
+    );
+    const otherMemberOnAdminNode = await loadCoValueOrFail(
+      admin.node,
+      otherMember.accountID,
+    );
+
+    group.addMember(readerOnAdminNode, "reader");
+    group.addMember(otherMemberOnAdminNode, "writer");
+
+    const groupOnReaderNode = await loadCoValueOrFail(reader.node, group.id);
+    expect(groupOnReaderNode.myRole()).toEqual("reader");
+
+    const otherMemberOnReaderNode = await loadCoValueOrFail(
+      reader.node,
+      otherMember.accountID,
+    );
+
+    await groupOnReaderNode.removeMember(otherMemberOnReaderNode);
+
+    expect(groupOnReaderNode.roleOf(otherMember.accountID)).toEqual("writer");
+  });
+});

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

@@ -4,6 +4,7 @@ import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
   blockMessageTypeOnOutgoingPeer,
+  connectedPeersWithMessagesTracking,
   loadCoValueOrFail,
   setupTestNode,
   waitFor,
@@ -76,8 +77,8 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "core -> storage | CONTENT Group header: true new: After: 0 New: 3",
         "storage -> core | KNOWN Group sessions: header/3",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "storage -> core | KNOWN Map sessions: header/1",
         "client -> edge-italy | LOAD Map sessions: empty",
+        "storage -> core | KNOWN Map sessions: header/1",
         "edge-italy -> core | LOAD Map sessions: empty",
         "core -> edge-italy | CONTENT Group header: true new: After: 0 New: 3",
         "edge-italy -> core | KNOWN Group sessions: header/3",
@@ -138,8 +139,8 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
         "core -> storage | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> core | KNOWN Group sessions: header/5",
         "core -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "storage -> core | KNOWN Map sessions: header/1",
         "client -> edge-italy | LOAD Map sessions: empty",
+        "storage -> core | KNOWN Map sessions: header/1",
         "edge-italy -> core | LOAD Map sessions: empty",
         "core -> edge-italy | CONTENT ParentGroup header: true new: After: 0 New: 6",
         "edge-italy -> core | KNOWN ParentGroup sessions: header/6",
@@ -355,6 +356,7 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       syncServer: storage.node,
     });
 
+    storagePeer.role = "storage";
     storagePeer.priority = 100;
 
     const group = coreServer.node.createGroup();
@@ -402,4 +404,60 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
 
     expect(mapOnClient.get("hello")).toEqual("world");
   });
+
+  test("a stuck server peer should not block the load from other server peers", async () => {
+    const client = setupTestNode();
+    const coreServer = setupTestNode({
+      isSyncServer: true,
+    });
+
+    const anotherServer = setupTestNode({});
+
+    const { peer: peerToCoreServer } = client.connectToSyncServer({
+      syncServerName: "core",
+      syncServer: coreServer.node,
+    });
+
+    const { peer1, peer2 } = connectedPeersWithMessagesTracking({
+      peer1: {
+        id: anotherServer.node.getCurrentAgent().id,
+        role: "server",
+        name: "another-server",
+      },
+      peer2: {
+        id: client.node.getCurrentAgent().id,
+        role: "client",
+        name: "client",
+      },
+    });
+
+    blockMessageTypeOnOutgoingPeer(peerToCoreServer, "load");
+
+    client.node.syncManager.addPeer(peer1);
+    anotherServer.node.syncManager.addPeer(peer2);
+
+    const group = anotherServer.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> another-server | LOAD Map sessions: empty",
+        "another-server -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> another-server | KNOWN Group sessions: header/3",
+        "another-server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> another-server | KNOWN Map sessions: header/1",
+      ]
+    `);
+
+    expect(mapOnClient.get("hello")).toEqual("world");
+  });
 });

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

@@ -1,7 +1,13 @@
 import { assert, beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue";
 import { WasmCrypto } from "../crypto/WasmCrypto";
-import { SyncMessagesLog, setupTestNode, waitFor } from "./testUtils";
+import {
+  SyncMessagesLog,
+  loadCoValueOrFail,
+  setupTestAccount,
+  setupTestNode,
+  waitFor,
+} from "./testUtils";
 
 let jazzCloud = setupTestNode({ isSyncServer: true });
 
@@ -146,7 +152,9 @@ describe("peer reconciliation", () => {
   });
 
   test("correctly handle server restarts in the middle of a sync", async () => {
-    const client = setupTestNode();
+    const client = setupTestNode({
+      connected: true,
+    });
 
     const group = client.node.createGroup();
     const map = group.createMap();
@@ -182,10 +190,90 @@ describe("peer reconciliation", () => {
         "server -> client | KNOWN Group sessions: empty",
         "client -> server | LOAD Map sessions: header/2",
         "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | LOAD Group sessions: empty",
         "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Group sessions: header/3",
         "server -> client | KNOWN Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/2",
+        "server -> client | KNOWN Map sessions: header/2",
+      ]
+    `);
+  });
+
+  test("correctly handle server restarts in the middle of a sync (2 - account)", async () => {
+    const client = await setupTestAccount({
+      connected: true,
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    await map.core.waitForSync();
+
+    jazzCloud.restart();
+    SyncMessagesLog.clear();
+    client.connectToSyncServer();
+
+    map.set("hello", "updated", "trusting");
+
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    client.connectToSyncServer();
+
+    await waitFor(() => {
+      const mapOnSyncServer = jazzCloud.node.getCoValue(map.id);
+
+      expect(mapOnSyncServer.loadingState).toBe("available");
+    });
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Account: client.node.expectCurrentAccount("client account").core,
+        Profile: client.node.expectProfileLoaded(client.accountID).core,
+        ProfileGroup: client.node.expectProfileLoaded(client.accountID).group
+          .core,
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Account sessions: header/4",
+        "server -> client | KNOWN Account sessions: empty",
+        "client -> server | LOAD ProfileGroup sessions: header/5",
+        "server -> client | KNOWN ProfileGroup sessions: empty",
+        "client -> server | LOAD Profile sessions: header/1",
+        "server -> client | KNOWN Profile sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "server -> client | KNOWN Group sessions: empty",
+        "client -> server | LOAD Map sessions: header/2",
+        "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: false new: After: 1 New: 1",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
         "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | LOAD Account sessions: empty",
+        "client -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "server -> client | LOAD Group sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN CORRECTION Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | KNOWN Account sessions: header/4",
+        "server -> client | KNOWN Group sessions: header/3",
         "server -> client | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Account sessions: header/4",
+        "server -> client | KNOWN Account sessions: header/4",
+        "client -> server | LOAD ProfileGroup sessions: header/5",
+        "server -> client | KNOWN ProfileGroup sessions: empty",
+        "client -> server | LOAD Profile sessions: header/1",
+        "server -> client | KNOWN Profile sessions: empty",
         "client -> server | LOAD Group sessions: header/3",
         "server -> client | KNOWN Group sessions: header/3",
         "client -> server | LOAD Map sessions: header/2",

package/src/tests/testUtils.ts

@@ -463,6 +463,7 @@ export function createMockStoragePeer(opts: {
     },
   });
 
+  peer1.role = "storage";
   peer1.priority = 100;
 
   storage.syncManager.addPeer(peer2);