cojson 0.14.1 → 0.14.18

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

@@ -157,6 +157,29 @@ describe("extend", () => {
 
     expect(childGroup.roleOf(node2.accountID)).toEqual(undefined);
   });
+
+  test("should be possible to extend a group without having membership in the parent group", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const parentGroup = node1.node.createGroup();
+    const childGroup = node2.node.createGroup();
+
+    const alice = await loadCoValueOrFail(node1.node, node3.accountID);
+    parentGroup.addMember(alice, "writer");
+
+    const parentGroupOnNode2 = await loadCoValueOrFail(
+      node2.node,
+      parentGroup.id,
+    );
+
+    childGroup.extend(parentGroupOnNode2);
+
+    expect(childGroup.roleOf(alice.id)).toBe("writer");
+  });
 });
 
 describe("unextend", () => {
@@ -191,6 +214,78 @@ describe("unextend", () => {
     expect(childGroup.roleOf(alice.id)).toBe(undefined);
   });
 
+  test("should work when the account has no access to the parent group but owns the writeKey", async () => {
+    const { node1, node2, node3 } = await createThreeConnectedNodes(
+      "server",
+      "server",
+      "server",
+    );
+
+    const parentGroup = node1.node.createGroup();
+    const childGroup = node2.node.createGroup();
+
+    const alice = await loadCoValueOrFail(node1.node, node3.accountID);
+    parentGroup.addMember(alice, "writer");
+
+    const parentGroupOnNode2 = await loadCoValueOrFail(
+      node2.node,
+      parentGroup.id,
+    );
+
+    childGroup.extend(parentGroupOnNode2);
+
+    expect(childGroup.roleOf(alice.id)).toBe("writer");
+
+    // `childGroup` no longer has `parentGroup`'s members
+    await childGroup.revokeExtend(parentGroup);
+    expect(childGroup.roleOf(alice.id)).toBe(undefined);
+
+    const map = childGroup.createMap();
+    map.set("test", "Hello!");
+
+    const mapOnAlice = await loadCoValueOrFail(node3.node, map.id);
+
+    expect(mapOnAlice.get("test")).toEqual(undefined);
+  });
+
+  test("should work when the account has no access to the parent group and not owns the writeKey", async () => {
+    const {
+      node1: bobNode,
+      node2: johnNode,
+      node3: aliceNode,
+    } = await createThreeConnectedNodes("server", "server", "server");
+
+    const parentGroup = bobNode.node.createGroup();
+    const childGroup = johnNode.node.createGroup();
+
+    const parentGroupOnJohn = await loadCoValueOrFail(
+      johnNode.node,
+      parentGroup.id,
+    );
+
+    childGroup.extend(parentGroupOnJohn);
+
+    const bob = await loadCoValueOrFail(johnNode.node, bobNode.accountID);
+    const alice = await loadCoValueOrFail(johnNode.node, aliceNode.accountID);
+    childGroup.addMember(alice, "admin");
+
+    const childGroupOnAlice = await loadCoValueOrFail(
+      aliceNode.node,
+      childGroup.id,
+    );
+
+    // `childGroup` no longer has `parentGroup`'s members
+    await childGroupOnAlice.revokeExtend(parentGroup);
+    expect(childGroupOnAlice.roleOf(bob.id)).toBe(undefined);
+
+    const map = childGroupOnAlice.createMap();
+    map.set("test", "Hello!");
+
+    const mapOnBob = await loadCoValueOrFail(bobNode.node, map.id);
+
+    expect(mapOnBob.get("test")).toEqual(undefined);
+  });
+
   test("should do nothing if applied to a group that is not extended", async () => {
     const { node1, node2, node3 } = await createThreeConnectedNodes(
       "server",

package/src/tests/permissions.test.ts

@@ -1982,40 +1982,6 @@ test("Writers, readers and writeOnly can set child extensions", () => {
   expect(groupAsReader.get(`child_${childGroup.id}`)).toEqual("extend");
 });
 
-test("Invitees can not set child extensions", () => {
-  const { group, node } = newGroupHighLevel();
-  const childGroup = node.createGroup();
-
-  const adminInvite = createAccountInNode(node);
-  const writerInvite = createAccountInNode(node);
-  const readerInvite = createAccountInNode(node);
-
-  group.addMember(adminInvite, "adminInvite");
-  group.addMember(writerInvite, "writerInvite");
-  group.addMember(readerInvite, "readerInvite");
-
-  const groupAsAdminInvite = expectGroup(
-    group.core.contentInClonedNodeWithDifferentAccount(adminInvite),
-  );
-
-  groupAsAdminInvite.set(`child_${childGroup.id}`, "extend", "trusting");
-  expect(groupAsAdminInvite.get(`child_${childGroup.id}`)).toBeUndefined();
-
-  const groupAsWriterInvite = expectGroup(
-    group.core.contentInClonedNodeWithDifferentAccount(writerInvite),
-  );
-
-  groupAsWriterInvite.set(`child_${childGroup.id}`, "extend", "trusting");
-  expect(groupAsWriterInvite.get(`child_${childGroup.id}`)).toBeUndefined();
-
-  const groupAsReaderInvite = expectGroup(
-    group.core.contentInClonedNodeWithDifferentAccount(readerInvite),
-  );
-
-  groupAsReaderInvite.set(`child_${childGroup.id}`, "extend", "trusting");
-  expect(groupAsReaderInvite.get(`child_${childGroup.id}`)).toBeUndefined();
-});
-
 test("Member roles are inherited by child groups (except invites)", () => {
   const { group, node, admin } = newGroupHighLevel();
   const parentGroup = node.createGroup();