cojson 0.9.23 → 0.10.0

package/src/tests/coValueState.test.ts

@@ -1,10 +1,24 @@
-import { describe, expect, test, vi } from "vitest";
+import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
 import { PeerState } from "../PeerState";
 import { CoValueCore } from "../coValueCore";
-import { CO_VALUE_LOADING_MAX_RETRIES, CoValueState } from "../coValueState";
+import { CO_VALUE_LOADING_CONFIG, CoValueState } from "../coValueState";
 import { RawCoID } from "../ids";
 import { Peer } from "../sync";
 
+const initialMaxRetries = CO_VALUE_LOADING_CONFIG.MAX_RETRIES;
+
+function mockMaxRetries(maxRetries: number) {
+  CO_VALUE_LOADING_CONFIG.MAX_RETRIES = maxRetries;
+
+  onTestFinished(() => {
+    CO_VALUE_LOADING_CONFIG.MAX_RETRIES = initialMaxRetries;
+  });
+}
+
+beforeEach(() => {
+  mockMaxRetries(5);
+});
+
 describe("CoValueState", () => {
   const mockCoValueId = "co_test123" as RawCoID;
 
@@ -92,18 +106,18 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toBe("unavailable");
@@ -145,8 +159,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -154,7 +168,7 @@ describe("CoValueState", () => {
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toBe("unavailable");
@@ -194,8 +208,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -203,7 +217,7 @@ describe("CoValueState", () => {
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_MAX_RETRIES,
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
     );
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toEqual("unavailable");
@@ -214,6 +228,8 @@ describe("CoValueState", () => {
   test("should handle the coValues that become available in between of the retries", async () => {
     vi.useFakeTimers();
 
+    mockMaxRetries(5);
+
     let retries = 0;
 
     const peer1 = createMockPeerState(
@@ -244,8 +260,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES + 1; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES + 1; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -278,8 +294,8 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
 
@@ -290,7 +306,9 @@ describe("CoValueState", () => {
 
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(5);
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
+    );
     expect(state.state.type).toBe("available");
     await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
 
@@ -300,6 +318,8 @@ describe("CoValueState", () => {
   test("should stop retrying when value becomes available", async () => {
     vi.useFakeTimers();
 
+    mockMaxRetries(5);
+
     let run = 1;
 
     const peer1 = createMockPeerState(
@@ -327,7 +347,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -372,7 +392,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -421,7 +441,7 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
@@ -449,12 +469,14 @@ describe("CoValueState", () => {
     const state = CoValueState.Unknown(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_MAX_RETRIES * 2; i++) {
+    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES * 2; i++) {
       await vi.runAllTimersAsync();
     }
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(5);
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
+      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
+    );
 
     expect(state.state.type).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toEqual("unavailable");

package/src/tests/group.test.ts

@@ -467,33 +467,6 @@ describe("writeOnly", () => {
     expect(mapOnNode3.get("test")).toEqual("Written from a writeOnly member");
   });
 
-  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("upgrade to writer roles should work correctly", async () => {
     const { node1, node2 } = await createTwoConnectedNodes("server", "server");
 
@@ -528,6 +501,35 @@ describe("writeOnly", () => {
     // The writer role should be able to see the edits from the admin
     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");
@@ -638,4 +640,205 @@ describe("writeOnly", () => {
 
     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("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");
+  });
 });