cojson 0.9.18 → 0.9.23

package/src/tests/SyncStateManager.test.ts

@@ -1,43 +1,36 @@
-import { describe, expect, onTestFinished, test, vi } from "vitest";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 import {
   GlobalSyncStateListenerCallback,
   PeerSyncStateListenerCallback,
 } from "../SyncStateManager.js";
-import { accountHeaderForInitialAgentSecret } from "../coValues/account.js";
 import { connectedPeers } from "../streamUtils.js";
 import { emptyKnownState } from "../sync.js";
 import {
   blockMessageTypeOnOutgoingPeer,
+  connectNodeToSyncServer,
   createTestNode,
-  createTwoConnectedNodes,
   loadCoValueOrFail,
+  setupSyncServer,
   waitFor,
 } from "./testUtils.js";
 
+let jazzCloud = setupSyncServer();
+
+beforeEach(async () => {
+  jazzCloud = setupSyncServer();
+});
+
 describe("SyncStateManager", () => {
   test("subscribeToUpdates receives updates when peer state changes", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     const subscriptionManager = client.syncManager.syncState;
 
     const updateSpy: GlobalSyncStateListenerCallback = vi.fn();
@@ -46,21 +39,21 @@ describe("SyncStateManager", () => {
     await client.syncManager.actuallySyncCoValue(map.core);
 
     expect(updateSpy).toHaveBeenCalledWith(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       emptyKnownState(map.core.id),
       { uploaded: false },
     );
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(updateSpy).toHaveBeenCalledWith(
-      "jazzCloudConnection",
-      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+      nodeToServerPeer.id,
+      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -73,42 +66,30 @@ describe("SyncStateManager", () => {
   test("subscribeToPeerUpdates receives updates only for specific peer", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
     const [clientStoragePeer] = connectedPeers("clientStorage", "unusedPeer", {
       peer1role: "client",
       peer2role: "server",
     });
 
-    client.syncManager.addPeer(jazzCloudAsPeer);
     client.syncManager.addPeer(clientStoragePeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
 
     const subscriptionManager = client.syncManager.syncState;
 
     const updateToJazzCloudSpy: PeerSyncStateListenerCallback = vi.fn();
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToPeerUpdates(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       updateToJazzCloudSpy,
     );
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
-      "clientStorage",
+      clientStoragePeer.id,
       updateToStorageSpy,
     );
 
@@ -126,13 +107,13 @@ describe("SyncStateManager", () => {
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
-      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -147,80 +128,50 @@ describe("SyncStateManager", () => {
   test("getIsCoValueFullyUploadedIntoPeer returns correct status", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     await client.syncManager.actuallySyncCoValue(map.core);
 
     const subscriptionManager = client.syncManager.syncState;
 
     expect(
-      subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
-        map.core.id,
-      ).uploaded,
+      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+        .uploaded,
     ).toBe(false);
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
 
     expect(
-      subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
-        map.core.id,
-      ).uploaded,
+      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+        .uploaded,
     ).toBe(true);
   });
 
   test("unsubscribe stops receiving updates", async () => {
     // Setup nodes
     const client = createTestNode();
-    const jazzCloud = createTestNode();
+    const { nodeToServerPeer } = connectNodeToSyncServer(client);
 
     // Create test data
     const group = client.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    // Connect nodes
-    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
-      "clientConnection",
-      "jazzCloudConnection",
-      {
-        peer1role: "client",
-        peer2role: "server",
-      },
-    );
-
-    client.syncManager.addPeer(jazzCloudAsPeer);
-    jazzCloud.syncManager.addPeer(clientAsPeer);
-
     const subscriptionManager = client.syncManager.syncState;
     const anyUpdateSpy = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
-      "jazzCloudConnection",
+      nodeToServerPeer.id,
       anyUpdateSpy,
     );
 
@@ -233,7 +184,7 @@ describe("SyncStateManager", () => {
 
     await waitFor(() => {
       return subscriptionManager.getCurrentSyncState(
-        "jazzCloudConnection",
+        nodeToServerPeer.id,
         map.core.id,
       ).uploaded;
     });
@@ -243,22 +194,21 @@ describe("SyncStateManager", () => {
 
   test("getCurrentSyncState should return the correct state", async () => {
     // Setup nodes
+    const clientNode = createTestNode();
+    const serverNode = jazzCloud;
     const {
-      node1: clientNode,
-      node2: serverNode,
-      node1ToNode2Peer: clientToServerPeer,
-      node2ToNode1Peer: serverToClientPeer,
-    } = await createTwoConnectedNodes("client", "server");
-
+      nodeToServerPeer: clientToServerPeer,
+      serverToNodePeer: serverToClientPeer,
+    } = connectNodeToSyncServer(clientNode);
     // Create test data
-    const group = clientNode.node.createGroup();
+    const group = clientNode.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
     group.addMember("everyone", "writer");
 
     // Initially should not be synced
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
@@ -268,13 +218,13 @@ describe("SyncStateManager", () => {
     await map.core.waitForSync();
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
-    const mapOnServer = await loadCoValueOrFail(serverNode.node, map.id);
+    const mapOnServer = await loadCoValueOrFail(serverNode, map.id);
 
     // Block the content messages so the client won't fully sync immediately
     const outgoing = blockMessageTypeOnOutgoingPeer(
@@ -285,14 +235,14 @@ describe("SyncStateManager", () => {
     mapOnServer.set("key2", "value2", "trusting");
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
-      serverNode.node.syncManager.syncState.getCurrentSyncState(
+      serverNode.syncManager.syncState.getCurrentSyncState(
         serverToClientPeer.id,
         map.core.id,
       ),
@@ -304,14 +254,14 @@ describe("SyncStateManager", () => {
     await mapOnServer.core.waitForSync();
 
     expect(
-      clientNode.node.syncManager.syncState.getCurrentSyncState(
+      clientNode.syncManager.syncState.getCurrentSyncState(
         clientToServerPeer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
-      serverNode.node.syncManager.syncState.getCurrentSyncState(
+      serverNode.syncManager.syncState.getCurrentSyncState(
         serverToClientPeer.id,
         map.core.id,
       ),

package/src/tests/permissions.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, test, vi } from "vitest";
 import { expectMap } from "../coValue.js";
 import { ControlledAgent } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
@@ -2908,3 +2908,61 @@ test("extend cycles should not break the keys rotation", () => {
 
   expect(map.get("test")).toEqual("Hello!");
 });
+
+test("Admin can remove themselves from a group", async () => {
+  const warnSpy = vi.spyOn(console, "warn");
+  const { group, admin } = newGroupHighLevel();
+
+  // Admin removes themselves
+  await group.removeMember(admin);
+
+  expect(group.myRole()).toBeUndefined();
+  expect(warnSpy).not.toHaveBeenCalled();
+});
+
+test("Can revoke read permission from 'everyone'", async () => {
+  const { group } = newGroupHighLevel();
+  const childObject = group.createMap();
+
+  // Give everyone read access
+  group.addMember("everyone", "reader");
+
+  childObject.set("foo", "bar", "private");
+  expect(childObject.get("foo")).toEqual("bar");
+
+  // Create a new account to verify access
+  const newAccount = new ControlledAgent(Crypto.newRandomAgentSecret(), Crypto);
+  const childContent = expectMap(
+    childObject.core
+      .testWithDifferentAccount(
+        newAccount,
+        Crypto.newRandomSessionID(newAccount.currentAgentID()._unsafeUnwrap()),
+      )
+      .getCurrentContent(),
+  );
+
+  // Verify the new account can read
+  expect(childContent.get("foo")).toEqual("bar");
+
+  // Revoke everyone's access
+  await group.removeMember("everyone");
+
+  childObject.set("foo", "updated after revoke", "private");
+
+  // Create another new account to verify access is revoked
+  const newAccount2 = new ControlledAgent(
+    Crypto.newRandomAgentSecret(),
+    Crypto,
+  );
+  const childContent2 = expectMap(
+    childObject.core
+      .testWithDifferentAccount(
+        newAccount2,
+        Crypto.newRandomSessionID(newAccount2.currentAgentID()._unsafeUnwrap()),
+      )
+      .getCurrentContent(),
+  );
+
+  // Verify the new account cannot read after revocation
+  expect(childContent2.get("foo")).toEqual("bar");
+});