cojson 0.13.30 → 0.13.33

package/dist/tests/group.test.js

@@ -4,7 +4,7 @@ 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 { createThreeConnectedNodes, createTwoConnectedNodes, loadCoValueOrFail, nodeWithRandomAgentAndSessionID, randomAgentAndSessionID, waitFor, } from "./testUtils.js";
+import { createThreeConnectedNodes, createTwoConnectedNodes, loadCoValueOrFail, nodeWithRandomAgentAndSessionID, } from "./testUtils.js";
 const Crypto = await WasmCrypto.create();
 test("Can create a RawCoMap in a group", () => {
     const node = nodeWithRandomAgentAndSessionID();
@@ -258,508 +258,4 @@ describe("writeOnly", () => {
         expect(mapOnNode2.get("test")).toEqual("Written from the writeOnly member");
     });
 });
-describe("extend", () => {
-    test("inherited writer roles should work correctly", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writer");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group);
-        childGroup.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writeOnly");
-        const map = childGroup.createMap();
-        map.set("test", "Written from the admin");
-        await map.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        // The writer role should be able to see the edits from the admin
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin");
-    });
-    test("a user should be able to extend a group when his role on the parent group is writer", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writer");
-        await group.core.waitForSync();
-        const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-        const childGroup = node2.node.createGroup();
-        childGroup.extend(groupOnNode2);
-        const map = childGroup.createMap();
-        map.set("test", "Written from node2");
-        await map.core.waitForSync();
-        await childGroup.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from node2");
-    });
-    test("a user should be able to extend a group when his role on the parent group is reader", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "reader");
-        await group.core.waitForSync();
-        const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-        const childGroup = node2.node.createGroup();
-        childGroup.extend(groupOnNode2);
-        const map = childGroup.createMap();
-        map.set("test", "Written from node2");
-        await map.core.waitForSync();
-        await childGroup.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from node2");
-    });
-    test("a user should be able to extend a group when his role on the parent group is writeOnly", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writeOnly");
-        await group.core.waitForSync();
-        const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-        const childGroup = node2.node.createGroup();
-        childGroup.extend(groupOnNode2);
-        const map = childGroup.createMap();
-        map.set("test", "Written from node2");
-        await map.core.waitForSync();
-        await childGroup.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from node2");
-    });
-    test("self-extend a group should not break anything", async () => {
-        const { node1 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.extend(group);
-        const map = group.createMap();
-        map.set("test", "Hello!");
-        expect(map.get("test")).toEqual("Hello!");
-    });
-    test("should not break when introducing extend cycles", async () => {
-        const { node1 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        const group2 = node1.node.createGroup();
-        const group3 = node1.node.createGroup();
-        group.extend(group2);
-        group2.extend(group3);
-        group3.extend(group);
-        const map = group.createMap();
-        map.set("test", "Hello!");
-        expect(map.get("test")).toEqual("Hello!");
-    });
-    test("a writerInvite role should not be inherited", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writerInvite");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group);
-        expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
-    });
-});
-describe("unextend", () => {
-    test("should revoke roles", async () => {
-        const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-        // `parentGroup` has `alice` as a writer
-        const parentGroup = node1.node.createGroup();
-        const alice = await loadCoValueOrFail(node1.node, node2.accountID);
-        parentGroup.addMember(alice, "writer");
-        // `alice`'s role in `parentGroup` is `"writer"`
-        expect(parentGroup.roleOf(alice.id)).toBe("writer");
-        // `childGroup` has `bob` as a reader
-        const childGroup = node1.node.createGroup();
-        const bob = await loadCoValueOrFail(node1.node, node3.accountID);
-        childGroup.addMember(bob, "reader");
-        // `bob`'s role in `childGroup` is `"reader"`
-        expect(childGroup.roleOf(bob.id)).toBe("reader");
-        // `childGroup` has `parentGroup`'s members (in this case, `alice` as a writer)
-        childGroup.extend(parentGroup);
-        expect(childGroup.roleOf(alice.id)).toBe("writer");
-        // `childGroup` no longer has `parentGroup`'s members
-        await childGroup.revokeExtend(parentGroup);
-        expect(childGroup.roleOf(bob.id)).toBe("reader");
-        expect(childGroup.roleOf(alice.id)).toBe(undefined);
-    });
-    test("should do nothing if applied to a group that is not extended", async () => {
-        const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-        const parentGroup = node1.node.createGroup();
-        const alice = await loadCoValueOrFail(node1.node, node2.accountID);
-        parentGroup.addMember(alice, "writer");
-        const childGroup = node1.node.createGroup();
-        const bob = await loadCoValueOrFail(node1.node, node3.accountID);
-        childGroup.addMember(bob, "reader");
-        await childGroup.revokeExtend(parentGroup);
-        expect(childGroup.roleOf(bob.id)).toBe("reader");
-        expect(childGroup.roleOf(alice.id)).toBe(undefined);
-    });
-    test("should not throw if the revokeExtend is called twice", async () => {
-        const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-        const parentGroup = node1.node.createGroup();
-        const alice = await loadCoValueOrFail(node1.node, node2.accountID);
-        parentGroup.addMember(alice, "writer");
-        const childGroup = node1.node.createGroup();
-        const bob = await loadCoValueOrFail(node1.node, node3.accountID);
-        childGroup.addMember(bob, "reader");
-        childGroup.extend(parentGroup);
-        await childGroup.revokeExtend(parentGroup);
-        await childGroup.revokeExtend(parentGroup);
-        expect(childGroup.roleOf(bob.id)).toBe("reader");
-        expect(childGroup.roleOf(alice.id)).toBe(undefined);
-    });
-});
-describe("extend with role mapping", () => {
-    test("mapping to writer should add the ability to write", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "reader");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "writer");
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-        const map = childGroup.createMap();
-        map.set("test", "Written from the admin");
-        await map.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin");
-        mapOnNode2.set("test", "Written from the inherited role");
-        expect(mapOnNode2.get("test")).toEqual("Written from the inherited role");
-        await mapOnNode2.core.waitForSync();
-        expect(map.get("test")).toEqual("Written from the inherited role");
-    });
-    test("mapping to reader should remove the ability to write", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writer");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "reader");
-        expect(childGroup.roleOf(node2.accountID)).toEqual("reader");
-        const map = childGroup.createMap();
-        map.set("test", "Written from the admin");
-        await map.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin");
-        mapOnNode2.set("test", "Should not be visible");
-        await mapOnNode2.core.waitForSync();
-        expect(map.get("test")).toEqual("Written from the admin");
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin");
-    });
-    test("mapping to admin should add the ability to add members", async () => {
-        const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "reader");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "admin");
-        expect(childGroup.roleOf(node2.accountID)).toEqual("admin");
-        await childGroup.core.waitForSync();
-        const childGroupOnNode2 = await loadCoValueOrFail(node2.node, childGroup.id);
-        childGroupOnNode2.addMember(await loadCoValueOrFail(node2.node, node3.accountID), "reader");
-        expect(childGroupOnNode2.roleOf(node3.accountID)).toEqual("reader");
-    });
-    test("mapping to reader should remove the ability to add members", async () => {
-        const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "admin");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "reader");
-        expect(childGroup.roleOf(node2.accountID)).toEqual("reader");
-        await childGroup.core.waitForSync();
-        const childGroupOnNode2 = await loadCoValueOrFail(node2.node, childGroup.id);
-        const accountToAdd = await loadCoValueOrFail(node2.node, node3.accountID);
-        expect(() => {
-            childGroupOnNode2.addMember(accountToAdd, "reader");
-        }).toThrow();
-        expect(childGroupOnNode2.roleOf(node3.accountID)).toEqual(undefined);
-    });
-    test("non-inheritable roles should not give access to the child group when role mapping is used", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writeOnly");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "reader");
-        expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
-        const map = childGroup.createMap();
-        map.set("test", "Written from the admin");
-        await map.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual(undefined);
-    });
-    test("invite roles should not give write access to the child group when role mapping is used", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        group.addMember(await loadCoValueOrFail(node1.node, node2.accountID), "writerInvite");
-        const childGroup = node1.node.createGroup();
-        childGroup.extend(group, "writer");
-        expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
-        const map = childGroup.createMap();
-        map.set("test", "Written from the admin");
-        await map.core.waitForSync();
-        const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin"); // The invite roles have access to the readKey hence can read the values on inherited groups
-        mapOnNode2.set("test", "Should not be visible");
-        await mapOnNode2.core.waitForSync();
-        expect(map.get("test")).toEqual("Written from the admin");
-        expect(mapOnNode2.get("test")).toEqual("Written from the admin");
-    });
-});
-describe("roleOf", () => {
-    test("returns direct role assignments", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2] = randomAgentAndSessionID();
-        group.addMember(agent2, "writer");
-        expect(group.roleOfInternal(agent2.id)).toEqual("writer");
-    });
-    test("returns undefined for non-members", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2] = randomAgentAndSessionID();
-        expect(group.roleOfInternal(agent2.id)).toEqual(undefined);
-    });
-    test("revoked roles return undefined", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2] = randomAgentAndSessionID();
-        group.addMember(agent2, "writer");
-        group.removeMemberInternal(agent2);
-        expect(group.roleOfInternal(agent2.id)).toEqual(undefined);
-    });
-    test("everyone role applies to all accounts", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2, sessionID2] = randomAgentAndSessionID();
-        group.addMemberInternal("everyone", "reader");
-        expect(group.roleOfInternal(agent2.id)).toEqual("reader");
-    });
-    test("account role overrides everyone role", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2, sessionID2] = randomAgentAndSessionID();
-        group.addMemberInternal("everyone", "writer");
-        group.addMember(agent2, "reader");
-        expect(group.roleOfInternal(agent2.id)).toEqual("reader");
-    });
-    test("Revoking access on everyone role should not affect existing members", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2, sessionID2] = randomAgentAndSessionID();
-        group.addMemberInternal("everyone", "reader");
-        group.addMember(agent2, "writer");
-        group.removeMemberInternal("everyone");
-        expect(group.roleOfInternal(agent2.id)).toEqual("writer");
-        expect(group.roleOfInternal("123")).toEqual(undefined);
-    });
-    test("Everyone role is inherited following the most permissive algorithm", () => {
-        const node = nodeWithRandomAgentAndSessionID();
-        const group = node.createGroup();
-        const [agent2, sessionID2] = randomAgentAndSessionID();
-        const parentGroup = node.createGroup();
-        parentGroup.addMemberInternal("everyone", "writer");
-        group.extend(parentGroup);
-        group.addMember(agent2, "reader");
-        expect(group.roleOfInternal(agent2.id)).toEqual("writer");
-    });
-    test("roleOf should prioritize explicit account role over everyone role in same group", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        const account2 = await loadCoValueOrFail(node1.node, node2.accountID);
-        // Add both everyone and specific account
-        group.addMember("everyone", "reader");
-        group.addMember(account2, "writer");
-        // Should return the explicit role, not everyone's role
-        expect(group.roleOf(node2.accountID)).toEqual("writer");
-        // Change everyone's role
-        group.addMember("everyone", "writer");
-        // Should still return the explicit role
-        expect(group.roleOf(node2.accountID)).toEqual("writer");
-    });
-    test("roleOf should prioritize inherited everyone role over explicit account role", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const parentGroup = node1.node.createGroup();
-        const childGroup = node1.node.createGroup();
-        const account2 = await loadCoValueOrFail(node1.node, node2.accountID);
-        // Set up inheritance
-        childGroup.extend(parentGroup);
-        // Add everyone to parent and account to child
-        parentGroup.addMember("everyone", "writer");
-        childGroup.addMember(account2, "reader");
-        // Should return the explicit role from child, not inherited everyone role
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-    });
-    test("roleOf should use everyone role when no explicit role exists", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const group = node1.node.createGroup();
-        // Add only everyone role
-        group.addMember("everyone", "reader");
-        // Should return everyone's role when no explicit role exists
-        expect(group.roleOf(node2.accountID)).toEqual("reader");
-    });
-    test("roleOf should inherit everyone role from parent when no explicit roles exist", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const parentGroup = node1.node.createGroup();
-        const childGroup = node1.node.createGroup();
-        // Set up inheritance
-        childGroup.extend(parentGroup);
-        // Add everyone to parent only
-        parentGroup.addMember("everyone", "reader");
-        // Should inherit everyone's role from parent
-        expect(childGroup.roleOf(node2.accountID)).toEqual("reader");
-    });
-    test("roleOf should handle everyone role inheritance through multiple levels", async () => {
-        const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-        const grandParentGroup = node1.node.createGroup();
-        const parentGroup = node1.node.createGroup();
-        const childGroup = node1.node.createGroup();
-        const childGroupOnNode2 = await loadCoValueOrFail(node2.node, childGroup.id);
-        const account2 = await loadCoValueOrFail(node1.node, node2.accountID);
-        // Set up inheritance chain
-        parentGroup.extend(grandParentGroup);
-        childGroup.extend(parentGroup);
-        // Add everyone to grandparent
-        grandParentGroup.addMember("everyone", "writer");
-        // Should inherit everyone's role from grandparent
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-        // Add explicit role in parent
-        parentGroup.addMember(account2, "reader");
-        // Should use parent's explicit role instead of grandparent's everyone role
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-        // Add explicit role in child
-        childGroup.addMember(account2, "admin");
-        await childGroup.core.waitForSync();
-        // Should use child's explicit role
-        expect(childGroup.roleOf(node2.accountID)).toEqual("admin");
-        // Remove child's explicit role
-        await childGroupOnNode2.removeMember(account2);
-        await childGroupOnNode2.core.waitForSync();
-        // Should fall back to parent's explicit role
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-        // Remove parent's explicit role
-        await parentGroup.removeMember(account2);
-        await childGroup.core.waitForSync();
-        // Should fall back to grandparent's everyone role
-        expect(childGroup.roleOf(node2.accountID)).toEqual("writer");
-    });
-    describe("writeOnly can be used as a role for everyone", () => {
-        test("writeOnly can be used as a role for everyone", async () => {
-            const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-        });
-        test("switching from everyone reader to writeOnly", async () => {
-            const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "reader");
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("test", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-        });
-        test("switching from everyone writer to writeOnly", async () => {
-            const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writer");
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("test", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-        });
-        test("switching from everyone writeOnly to reader", async () => {
-            const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("fromAdmin", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-            group.addMember("everyone", "reader");
-            await group.core.waitForSync();
-            mapOnNode2.set("test", "Updated after the downgrade");
-            expect(mapOnNode2.get("test")).toEqual("Written from everyone");
-            expect(mapOnNode2.get("fromAdmin")).toEqual("Written from admin");
-        });
-        test("switching from everyone writeOnly to writer", async () => {
-            const { node1, node2 } = await createTwoConnectedNodes("server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("fromAdmin", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-            group.addMember("everyone", "writer");
-            await group.core.waitForSync();
-            mapOnNode2.set("test", "Updated after the upgrade");
-            expect(mapOnNode2.get("test")).toEqual("Updated after the upgrade");
-            expect(mapOnNode2.get("fromAdmin")).toEqual("Written from admin");
-        });
-        test("adding a reader member after writeOnly", async () => {
-            const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("fromAdmin", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-            const account3 = await loadCoValueOrFail(node1.node, node3.accountID);
-            group.addMember(account3, "reader");
-            await group.core.waitForSync();
-            const mapOnNode3 = await loadCoValueOrFail(node3.node, map.id);
-            expect(mapOnNode3.get("test")).toEqual("Written from everyone");
-        });
-        test.skip("adding a reader member while creating the writeOnly keys", async () => {
-            const { node1, node2, node3 } = await createThreeConnectedNodes("server", "server", "server");
-            const account3 = await loadCoValueOrFail(node1.node, node3.accountID);
-            const group = node1.node.createGroup();
-            group.addMember("everyone", "writeOnly");
-            const map = group.createMap();
-            map.set("fromAdmin", "Written from admin");
-            const groupOnNode2 = await loadCoValueOrFail(node2.node, group.id);
-            expect(groupOnNode2.myRole()).toEqual("writeOnly");
-            const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
-            group.addMember(account3, "reader");
-            expect(mapOnNode2.get("test")).toEqual(undefined);
-            mapOnNode2.set("test", "Written from everyone");
-            await waitFor(async () => {
-                const mapOnNode1 = await loadCoValueOrFail(node1.node, map.id);
-                expect(mapOnNode1.get("test")).toEqual("Written from everyone");
-            });
-            await group.core.waitForSync();
-            const mapOnNode3 = await loadCoValueOrFail(node3.node, map.id);
-            expect(mapOnNode3.get("test")).toEqual("Written from everyone");
-        });
-    });
-});
 //# sourceMappingURL=group.test.js.map