cojson 0.18.0 → 0.18.2

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

@@ -77,236 +77,138 @@ describe("Group.removeMember", () => {
     expect(mapOnAliceNode.get("test")).toEqual("test");
   });
 
-  test("a reader member should be able to revoke themselves", async () => {
+  for (const member of ["writer", "reader", "writeOnly", "admin"] as const) {
+    test(`${member} member should be able to revoke themselves`, async () => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const client = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+      group.addMember(
+        await loadCoValueOrFail(admin.node, client.accountID),
+        member,
+      );
+
+      await group.core.waitForSync();
+
+      const loadedGroup = await loadCoValueOrFail(client.node, group.id);
+      expect(loadedGroup.myRole()).toEqual(member);
+
+      await loadedGroup.removeMember(client.node.expectCurrentAccount(member));
+
+      expect(loadedGroup.myRole()).toEqual(undefined);
+    });
+  }
+
+  for (const member of ["writer", "reader", "writeOnly"] as const) {
+    test(`${member} member cannot remove other accounts`, async () => {
+      const admin = await setupTestAccount({
+        connected: true,
+      });
+
+      const writer = await setupTestAccount({
+        connected: true,
+      });
+
+      const writeOnly = await setupTestAccount({
+        connected: true,
+      });
+
+      const reader = await setupTestAccount({
+        connected: true,
+      });
+
+      const client = await setupTestAccount({
+        connected: true,
+      });
+
+      const group = admin.node.createGroup();
+      group.addMember(
+        await loadCoValueOrFail(admin.node, writer.accountID),
+        "writer",
+      );
+      group.addMember(
+        await loadCoValueOrFail(admin.node, reader.accountID),
+        "reader",
+      );
+      group.addMember(
+        await loadCoValueOrFail(admin.node, writeOnly.accountID),
+        "writeOnly",
+      );
+      group.addMember(
+        await loadCoValueOrFail(admin.node, client.accountID),
+        member,
+      );
+
+      const loadedGroup = await loadCoValueOrFail(client.node, group.id);
+
+      loadedGroup.removeMember(
+        await loadCoValueOrFail(client.node, reader.accountID),
+      );
+      loadedGroup.removeMember(
+        await loadCoValueOrFail(client.node, writeOnly.accountID),
+      );
+      loadedGroup.removeMember(
+        await loadCoValueOrFail(client.node, writer.accountID),
+      );
+      loadedGroup.removeMember(
+        await loadCoValueOrFail(client.node, admin.accountID),
+      );
+
+      expect(loadedGroup.roleOf(reader.accountID)).toEqual("reader");
+      expect(loadedGroup.roleOf(writer.accountID)).toEqual("writer");
+      expect(loadedGroup.roleOf(writeOnly.accountID)).toEqual("writeOnly");
+      expect(loadedGroup.roleOf(admin.accountID)).toEqual("admin");
+
+      await loadedGroup.core.waitForSync();
+
+      expect((await loadCoValueOrFail(reader.node, group.id)).myRole()).toEqual(
+        "reader",
+      );
+      expect((await loadCoValueOrFail(writer.node, group.id)).myRole()).toEqual(
+        "writer",
+      );
+      expect(
+        (await loadCoValueOrFail(writeOnly.node, group.id)).myRole(),
+      ).toEqual("writeOnly");
+      expect((await loadCoValueOrFail(admin.node, group.id)).myRole()).toEqual(
+        "admin",
+      );
+    });
+  }
+
+  test(`admin member cannot remove other admins`, 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({
+    const client = await setupTestAccount({
       connected: true,
     });
 
     const group = admin.node.createGroup();
-    const writerOnAdminNode = await loadCoValueOrFail(
-      admin.node,
-      writer.accountID,
+    group.addMember(
+      await loadCoValueOrFail(admin.node, client.accountID),
+      "admin",
     );
-    group.addMember(writerOnAdminNode, "writer");
 
-    const groupOnWriterNode = await loadCoValueOrFail(writer.node, group.id);
-    expect(groupOnWriterNode.myRole()).toEqual("writer");
+    const loadedGroup = await loadCoValueOrFail(client.node, group.id);
 
-    await groupOnWriterNode.removeMember(
-      writer.node.expectCurrentAccount("writer"),
+    loadedGroup.removeMember(
+      await loadCoValueOrFail(client.node, admin.accountID),
     );
 
-    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,
-    });
+    expect(loadedGroup.roleOf(admin.accountID)).toEqual("admin");
 
-    const group = admin.node.createGroup();
-    const writeOnlyOnAdminNode = await loadCoValueOrFail(
-      admin.node,
-      writeOnly.accountID,
-    );
-    group.addMember(writeOnlyOnAdminNode, "writeOnly");
+    await loadedGroup.core.waitForSync();
 
-    const groupOnWriteOnlyNode = await loadCoValueOrFail(
-      writeOnly.node,
-      group.id,
+    expect((await loadCoValueOrFail(admin.node, group.id)).myRole()).toEqual(
+      "admin",
     );
-    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");
   });
 
   test("removing a member when inheriting a group where the user lacks read rights", async () => {

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

@@ -132,6 +132,54 @@ describe("loading coValues from server", () => {
     `);
   });
 
+  test("loading a branch", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    const branchName = "feature-branch";
+
+    map.set("key1", "value1");
+    map.set("key2", "value2");
+
+    const branch = await jazzCloud.node.checkoutBranch(map.id, branchName);
+
+    if (branch === "unavailable") {
+      throw new Error("Branch is unavailable");
+    }
+
+    branch.set("branchKey", "branchValue");
+
+    SyncMessagesLog.clear();
+
+    const loadedBranch = await loadCoValueOrFail(client.node, branch.id);
+
+    expect(branch.get("key1")).toBe("value1");
+    expect(branch.get("key2")).toBe("value2");
+    expect(branch.get("branchKey")).toBe("branchValue");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+        Branch: branch.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Branch sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "server -> client | CONTENT Branch header: true new: After: 0 New: 2",
+        "client -> server | KNOWN Group sessions: header/5",
+        "client -> server | KNOWN Map sessions: header/2",
+        "client -> server | KNOWN Branch sessions: header/2",
+      ]
+    `);
+  });
+
   test("unavailable coValue retry with skipRetry set to false", async () => {
     const client = setupTestNode();
     const client2 = setupTestNode();

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

@@ -173,9 +173,9 @@ describe("client with storage syncs with server", () => {
 
     const loadedValue = await loadCoValueOrFail(client.node, map.id);
 
-    const validTransactions = determineValidTransactions(loadedValue.core);
-
-    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+    expect(loadedValue.core.verifiedTransactions[0]?.tx.meta).toBe(
+      `{"meta":true}`,
+    );
 
     expect(
       SyncMessagesLog.getMessages({
@@ -193,6 +193,57 @@ describe("client with storage syncs with server", () => {
     `);
   });
 
+  test("loading a branch from storage", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+    const { storage } = client.addStorage();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    const branchName = "feature-branch";
+
+    map.set("key1", "value1");
+    map.set("key2", "value2");
+
+    const branch = await client.node.checkoutBranch(map.id, branchName);
+
+    if (branch === "unavailable") {
+      throw new Error("Branch is unavailable");
+    }
+
+    branch.set("branchKey", "branchValue");
+    await branch.core.waitForSync();
+
+    client.restart();
+    client.addStorage({
+      storage,
+    });
+
+    SyncMessagesLog.clear();
+
+    const loadedBranch = await loadCoValueOrFail(client.node, branch.id);
+
+    expect(branch.get("key1")).toBe("value1");
+    expect(branch.get("key2")).toBe("value2");
+    expect(branch.get("branchKey")).toBe("branchValue");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+        Branch: branch.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | LOAD Branch sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "storage -> client | CONTENT Branch header: true new: After: 0 New: 2",
+      ]
+    `);
+  });
+
   test("updating a coValue while offline", async () => {
     const client = setupTestNode();
 

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

@@ -52,6 +52,56 @@ describe("client to server upload", () => {
     `);
   });
 
+  test("creating a branch", async () => {
+    const client = setupTestNode({
+      connected: true,
+    });
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+    const map = group.createMap();
+    const branchName = "feature-branch";
+
+    map.set("key1", "value1");
+    map.set("key2", "value2");
+
+    await map.core.waitForSync();
+
+    SyncMessagesLog.clear();
+
+    const branch = await client.node.checkoutBranch(map.id, branchName);
+
+    if (branch === "unavailable") {
+      throw new Error("Branch is unavailable");
+    }
+
+    branch.set("branchKey", "branchValue");
+
+    await branch.core.waitForSync();
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+        Branch: branch.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 2",
+        "client -> server | KNOWN Group sessions: header/5",
+        "client -> server | KNOWN Map sessions: header/2",
+        "client -> server | LOAD Branch sessions: empty",
+        "server -> client | KNOWN Branch sessions: empty",
+        "client -> server | CONTENT Branch header: true new: After: 0 New: 1",
+        "client -> server | CONTENT Branch header: false new: After: 1 New: 1",
+        "server -> client | KNOWN Branch sessions: header/1",
+        "server -> client | KNOWN Branch sessions: header/2",
+      ]
+    `);
+  });
+
   test("syncs meta information", async () => {
     const client = setupTestNode({
       connected: true,
@@ -67,9 +117,9 @@ describe("client to server upload", () => {
 
     const loadedValue = await loadCoValueOrFail(jazzCloud.node, map.id);
 
-    const validTransactions = determineValidTransactions(loadedValue.core);
-
-    expect(validTransactions[0]?.tx.meta).toBe(`{"meta":true}`);
+    expect(loadedValue.core.verifiedTransactions[0]?.tx.meta).toBe(
+      `{"meta":true}`,
+    );
 
     expect(
       SyncMessagesLog.getMessages({