jazz-tools 0.17.14 → 0.18.1

package/src/tools/tests/groupsAndAccounts.test.ts

@@ -35,12 +35,14 @@ describe("Custom accounts and groups", async () => {
         type P = typeof account.profile;
         const _p: P = {} as Loaded<typeof CustomProfile> | null;
         if (creationProps) {
-          console.log("In migration!");
           const profileGroup = Group.create({ owner: account });
           profileGroup.addMember("everyone", "reader");
-          account.profile = CustomProfile.create(
-            { name: creationProps.name, color: "blue" },
-            profileGroup,
+          account.$jazz.set(
+            "profile",
+            CustomProfile.create(
+              { name: creationProps.name, color: "blue" },
+              profileGroup,
+            ),
           );
         }
       });
@@ -58,38 +60,14 @@ describe("Custom accounts and groups", async () => {
     const group = Group.create({ owner: me });
     group.addMember("everyone", "reader");
 
-    expect(group.members).toMatchObject([{ id: me.id, role: "admin" }]);
+    expect(group.members).toMatchObject([{ id: me.$jazz.id, role: "admin" }]);
 
-    const meAsMember = group.members.find((member) => member.id === me.id);
+    const meAsMember = group.members.find(
+      (member) => member.id === me.$jazz.id,
+    );
     assert(meAsMember?.account);
     expect((meAsMember?.account).profile?.name).toBe("Hermes Puggington");
   });
-
-  test("Should throw when creating a profile with an account as owner", async () => {
-    const CustomAccount = co
-      .account()
-      .withMigration(
-        (
-          account: Loaded<typeof CustomAccount>,
-          creationProps?: { name: string },
-        ) => {
-          if (creationProps) {
-            account.profile = co.profile().create(
-              { name: creationProps.name },
-              // @ts-expect-error - only groups can own profiles, but we want to also perform a runtime check
-              account,
-            );
-          }
-        },
-      );
-
-    await expect(() =>
-      CustomAccount.create({
-        creationProps: { name: "Hermes Puggington" },
-        crypto: Crypto,
-      }),
-    ).rejects.toThrowError("Profile must be owned by a Group");
-  });
 });
 
 describe("Group inheritance", () => {
@@ -116,15 +94,17 @@ describe("Group inheritance", () => {
 
     const mapInChild = TestMap.create({ title: "In Child" }, { owner: group });
 
-    const mapAsReader = await TestMap.load(mapInChild.id, { loadAs: reader });
+    const mapAsReader = await TestMap.load(mapInChild.$jazz.id, {
+      loadAs: reader,
+    });
     expect(mapAsReader?.title).toBe("In Child");
 
     await parentGroup.removeMember(reader);
 
-    mapInChild.title = "In Child (updated)";
+    mapInChild.$jazz.set("title", "In Child (updated)");
 
     await waitFor(async () => {
-      const mapAsReaderAfterUpdate = await TestMap.load(mapInChild.id, {
+      const mapAsReaderAfterUpdate = await TestMap.load(mapInChild.$jazz.id, {
         loadAs: reader,
       });
       expect(mapAsReaderAfterUpdate).toBe(null);
@@ -155,20 +135,23 @@ describe("Group inheritance", () => {
       { owner: group },
     );
 
-    const mapAsReader = await TestMap.load(mapInGrandChild.id, {
+    const mapAsReader = await TestMap.load(mapInGrandChild.$jazz.id, {
       loadAs: reader,
     });
     expect(mapAsReader?.title).toBe("In Grand Child");
 
     await grandParentGroup.removeMember(reader);
 
-    await grandParentGroup.waitForSync();
+    await grandParentGroup.$jazz.waitForSync();
 
-    mapInGrandChild.title = "In Grand Child (updated)";
+    mapInGrandChild.$jazz.set("title", "In Grand Child (updated)");
 
-    const mapAsReaderAfterUpdate = await TestMap.load(mapInGrandChild.id, {
-      loadAs: reader,
-    });
+    const mapAsReaderAfterUpdate = await TestMap.load(
+      mapInGrandChild.$jazz.id,
+      {
+        loadAs: reader,
+      },
+    );
     expect(mapAsReaderAfterUpdate).toBe(null);
   });
 
@@ -189,36 +172,29 @@ describe("Group inheritance", () => {
 
     expect(parentGroups).toHaveLength(1);
     expect(parentGroups).toContainEqual(
-      expect.objectContaining({ id: parentGroup.id }),
+      expect.objectContaining({
+        $jazz: expect.objectContaining({ id: parentGroup.$jazz.id }),
+      }),
     );
 
     expect(parentGroups[0]?.getParentGroups()).toContainEqual(
-      expect.objectContaining({ id: grandParentGroup.id }),
+      expect.objectContaining({
+        $jazz: expect.objectContaining({ id: grandParentGroup.$jazz.id }),
+      }),
     );
   });
 
-  test("Account.getParentGroups should return an empty array", async () => {
-    const account = await co.account().create({
-      creationProps: { name: "Test Account" },
-      crypto: Crypto,
-    });
-
-    const parentGroups = account.getParentGroups();
-
-    expect(parentGroups).toEqual([]);
-  });
-
   test("waitForSync should resolve when the value is uploaded", async () => {
     const { clientNode, serverNode, clientAccount } = await setupTwoNodes();
 
     const group = Group.create({ owner: clientAccount });
 
-    await group.waitForSync({ timeout: 1000 });
+    await group.$jazz.waitForSync({ timeout: 1000 });
 
     // Killing the client node so the serverNode can't load the map from it
     clientNode.gracefulShutdown();
 
-    const loadedGroup = await serverNode.load(group._raw.id);
+    const loadedGroup = await serverNode.load(group.$jazz.raw.id);
 
     expect(loadedGroup).not.toBe("unavailable");
   });
@@ -257,7 +233,7 @@ describe("Group inheritance", () => {
 
   test("typescript should show an error when adding a member with a non-account role", async () => {
     const account = await createJazzTestAccount({});
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
 
     const group = Group.create();
 
@@ -270,17 +246,17 @@ describe("Group inheritance", () => {
 
     expect(group.members).not.toContainEqual(
       expect.objectContaining({
-        id: account.id,
+        id: account.$jazz.id,
         role: "readerInvite",
       }),
     );
 
-    expect(group.getRoleOf(account.id)).toBe("readerInvite");
+    expect(group.getRoleOf(account.$jazz.id)).toBe("readerInvite");
   });
 
   test("adding a group member as writeOnly should fail", async () => {
     const account = await createJazzTestAccount({});
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
 
     const parentGroup = Group.create();
     const group = Group.create();
@@ -292,29 +268,29 @@ describe("Group inheritance", () => {
 
   test("Removing member group", async () => {
     const alice = await createJazzTestAccount({});
-    await alice.waitForAllCoValuesSync();
+    await alice.$jazz.waitForAllCoValuesSync();
     const bob = await createJazzTestAccount({});
-    await bob.waitForAllCoValuesSync();
+    await bob.$jazz.waitForAllCoValuesSync();
 
     const parentGroup = Group.create();
     // `parentGroup` has `alice` as a writer
     parentGroup.addMember(alice, "writer");
-    expect(parentGroup.getRoleOf(alice.id)).toBe("writer");
+    expect(parentGroup.getRoleOf(alice.$jazz.id)).toBe("writer");
 
     const group = Group.create();
     // `group` has `bob` as a reader
     group.addMember(bob, "reader");
-    expect(group.getRoleOf(bob.id)).toBe("reader");
+    expect(group.getRoleOf(bob.$jazz.id)).toBe("reader");
 
     group.addMember(parentGroup);
     // `group` has `parentGroup`'s members (in this case, `alice` as a writer)
-    expect(group.getRoleOf(bob.id)).toBe("reader");
-    expect(group.getRoleOf(alice.id)).toBe("writer");
+    expect(group.getRoleOf(bob.$jazz.id)).toBe("reader");
+    expect(group.getRoleOf(alice.$jazz.id)).toBe("writer");
 
     // `group` no longer has `parentGroup`'s members
     await group.removeMember(parentGroup);
-    expect(group.getRoleOf(bob.id)).toBe("reader");
-    expect(group.getRoleOf(alice.id)).toBe(undefined);
+    expect(group.getRoleOf(bob.$jazz.id)).toBe("reader");
+    expect(group.getRoleOf(alice.$jazz.id)).toBe(undefined);
   });
 
   describe("when creating nested CoValues from a JSON object", () => {
@@ -348,9 +324,9 @@ describe("Group inheritance", () => {
       const me = co.account().getMe();
       const task = board.columns[0]![0]!;
 
-      const boardAsWriter = await Board.load(board.id, { loadAs: me });
+      const boardAsWriter = await Board.load(board.$jazz.id, { loadAs: me });
       expect(boardAsWriter?.title).toEqual("My board");
-      const taskAsWriter = await Task.load(task.id, { loadAs: me });
+      const taskAsWriter = await Task.load(task.$jazz.id, { loadAs: me });
       expect(taskAsWriter?.toString()).toEqual("Task 1.1");
     });
 
@@ -361,12 +337,14 @@ describe("Group inheritance", () => {
       });
 
       const task = board.columns[0]![0]!;
-      const taskGroup = task._owner.castAs(Group);
+      const taskGroup = task.$jazz.owner;
       taskGroup.addMember(reader, "reader");
 
-      const taskAsReader = await Task.load(task.id, { loadAs: reader });
+      const taskAsReader = await Task.load(task.$jazz.id, { loadAs: reader });
       expect(taskAsReader?.toString()).toEqual("Task 1.1");
-      const boardAsReader = await Board.load(board.id, { loadAs: reader });
+      const boardAsReader = await Board.load(board.$jazz.id, {
+        loadAs: reader,
+      });
       expect(boardAsReader).toBeNull();
     });
   });
@@ -380,34 +358,34 @@ describe("Group.getRoleOf", () => {
   test("returns correct role for admin", async () => {
     const group = Group.create();
     const admin = await createJazzTestAccount({});
-    await admin.waitForAllCoValuesSync();
+    await admin.$jazz.waitForAllCoValuesSync();
     group.addMember(admin, "admin");
-    expect(group.getRoleOf(admin.id)).toBe("admin");
+    expect(group.getRoleOf(admin.$jazz.id)).toBe("admin");
     expect(group.getRoleOf("me")).toBe("admin");
   });
 
   test("returns correct role for writer", async () => {
     const group = Group.create();
     const writer = await createJazzTestAccount({});
-    await writer.waitForAllCoValuesSync();
+    await writer.$jazz.waitForAllCoValuesSync();
     group.addMember(writer, "writer");
-    expect(group.getRoleOf(writer.id)).toBe("writer");
+    expect(group.getRoleOf(writer.$jazz.id)).toBe("writer");
   });
 
   test("returns correct role for reader", async () => {
     const group = Group.create();
     const reader = await createJazzTestAccount({});
-    await reader.waitForAllCoValuesSync();
+    await reader.$jazz.waitForAllCoValuesSync();
     group.addMember(reader, "reader");
-    expect(group.getRoleOf(reader.id)).toBe("reader");
+    expect(group.getRoleOf(reader.$jazz.id)).toBe("reader");
   });
 
   test("returns correct role for writeOnly", async () => {
     const group = Group.create();
     const writeOnly = await createJazzTestAccount({});
-    await writeOnly.waitForAllCoValuesSync();
+    await writeOnly.$jazz.waitForAllCoValuesSync();
     group.addMember(writeOnly, "writeOnly");
-    expect(group.getRoleOf(writeOnly.id)).toBe("writeOnly");
+    expect(group.getRoleOf(writeOnly.$jazz.id)).toBe("writeOnly");
   });
 
   test("returns correct role for everyone", () => {
@@ -429,7 +407,7 @@ describe("Group.getRoleOf with 'me' parameter", () => {
 
   test("returns correct role for 'me' when current account is writer", async () => {
     const account = await createJazzTestAccount();
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
     const group = Group.create({ owner: account });
 
     group.addMember(co.account().getMe(), "writer");
@@ -439,7 +417,7 @@ describe("Group.getRoleOf with 'me' parameter", () => {
 
   test("returns correct role for 'me' when current account is reader", async () => {
     const account = await createJazzTestAccount();
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
     const group = Group.create({ owner: account });
 
     group.addMember(co.account().getMe(), "reader");
@@ -449,7 +427,7 @@ describe("Group.getRoleOf with 'me' parameter", () => {
 
   test("returns undefined for 'me' when current account has no role", async () => {
     const account = await createJazzTestAccount();
-    await account.waitForAllCoValuesSync();
+    await account.$jazz.waitForAllCoValuesSync();
     const group = Group.create({ owner: account });
 
     expect(group.getRoleOf("me")).toBeUndefined();
@@ -468,7 +446,7 @@ describe("Account permissions", () => {
     });
 
     // Account should be admin of itself
-    expect(account.getRoleOf(account.id)).toBe("admin");
+    expect(account.getRoleOf(account.$jazz.id)).toBe("admin");
 
     // The GlobalMe is not this account
     expect(account.getRoleOf("me")).toBe(undefined);
@@ -479,22 +457,11 @@ describe("Account permissions", () => {
       creationProps: { name: "Other Account" },
       crypto: Crypto,
     });
-    expect(account.getRoleOf(otherAccount.id)).toBeUndefined();
+    expect(account.getRoleOf(otherAccount.$jazz.id)).toBeUndefined();
 
     // Everyone should have no role
     expect(account.getRoleOf("everyone")).toBeUndefined();
   });
-
-  test("members array only contains self as admin", async () => {
-    const account = await co.account().create({
-      creationProps: { name: "Test Account" },
-      crypto: Crypto,
-    });
-
-    expect(account.members).toEqual([
-      { id: account.id, role: "admin", account: account, ref: expect.any(Ref) },
-    ]);
-  });
 });
 
 describe("Account permissions", () => {
@@ -612,6 +579,232 @@ describe("Account permissions", () => {
     expect(nonMember.canWrite(testObject)).toBe(false);
     expect(nonMember.canAdmin(testObject)).toBe(false);
   });
+
+  describe("permissions over Groups and Accounts", () => {
+    describe("read", () => {
+      test("can read all Accounts", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        expect(account.canRead(otherAccount)).toBe(true);
+      });
+
+      test("can read all groups", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create();
+
+        expect(account.canRead(group)).toBe(true);
+      });
+    });
+
+    describe("write", () => {
+      test("can write Account if it's itself", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        expect(account.canWrite(account)).toBe(true);
+      });
+
+      test("cannot write other accounts", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        expect(account.canWrite(otherAccount)).toBe(false);
+      });
+
+      test("can write Group if it's a writer for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writer");
+
+        expect(account.canWrite(group)).toBe(true);
+      });
+
+      test("can write Group if it's an admin for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "admin");
+
+        expect(account.canWrite(group)).toBe(true);
+      });
+
+      test("cannot write Group if it has writeOnly permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writeOnly");
+
+        expect(account.canWrite(group)).toBe(false);
+      });
+
+      test("cannot write Group if it's a reader for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "reader");
+
+        expect(account.canWrite(group)).toBe(false);
+      });
+
+      test("cannot write Group if it has no permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        expect(account.canWrite(group)).toBe(false);
+      });
+    });
+
+    describe("admin", () => {
+      test("can admin Account if it's itself", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        expect(account.canAdmin(account)).toBe(true);
+      });
+
+      test("cannot admin other accounts", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        expect(account.canAdmin(otherAccount)).toBe(false);
+      });
+
+      test("can admin Group if it's an admin for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "admin");
+
+        expect(account.canAdmin(group)).toBe(true);
+      });
+
+      test("cannot admin Group if it's a writer for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writer");
+
+        expect(account.canAdmin(group)).toBe(false);
+      });
+
+      test("cannot admin Group if it has writeOnly permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "writeOnly");
+
+        expect(account.canAdmin(group)).toBe(false);
+      });
+
+      test("cannot write Group if it's a reader for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        group.addMember(account, "reader");
+
+        expect(account.canAdmin(group)).toBe(false);
+      });
+
+      test("cannot write Group if it has no permissions for that group", async () => {
+        const account = await co.account().create({
+          creationProps: { name: "Test Account" },
+          crypto: Crypto,
+        });
+        const otherAccount = await co.account().create({
+          creationProps: { name: "Other Account" },
+          crypto: Crypto,
+        });
+        const group = Group.create({ owner: otherAccount });
+
+        expect(account.canAdmin(group)).toBe(false);
+      });
+    });
+  });
 });
 
 describe("Group.members", () => {
@@ -619,21 +812,25 @@ describe("Group.members", () => {
     const childGroup = Group.create();
 
     const bob = await createJazzTestAccount({});
-    await bob.waitForAllCoValuesSync();
+    await bob.$jazz.waitForAllCoValuesSync();
 
     childGroup.addMember(bob, "reader");
-    expect(childGroup.getRoleOf(bob.id)).toBe("reader");
+    expect(childGroup.getRoleOf(bob.$jazz.id)).toBe("reader");
 
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
         role: "admin",
       }),
       expect.objectContaining({
         account: expect.objectContaining({
-          id: bob.id,
+          $jazz: expect.objectContaining({
+            id: bob.$jazz.id,
+          }),
         }),
         role: "reader",
       }),
@@ -645,23 +842,27 @@ describe("Group.members", () => {
     const parentGroup = Group.create();
 
     const bob = await createJazzTestAccount({});
-    await bob.waitForAllCoValuesSync();
+    await bob.$jazz.waitForAllCoValuesSync();
 
     parentGroup.addMember(bob, "writer");
     childGroup.addMember(parentGroup, "reader");
 
-    expect(childGroup.getRoleOf(bob.id)).toBe("reader");
+    expect(childGroup.getRoleOf(bob.$jazz.id)).toBe("reader");
 
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
         role: "admin",
       }),
       expect.objectContaining({
         account: expect.objectContaining({
-          id: bob.id,
+          $jazz: expect.objectContaining({
+            id: bob.$jazz.id,
+          }),
         }),
         role: "reader",
       }),
@@ -677,7 +878,9 @@ describe("Group.members", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
         role: "admin",
       }),
@@ -688,17 +891,19 @@ describe("Group.members", () => {
     const childGroup = Group.create();
 
     const bob = await createJazzTestAccount({});
-    await bob.waitForAllCoValuesSync();
+    await bob.$jazz.waitForAllCoValuesSync();
 
     childGroup.addMember(bob, "reader");
     await childGroup.removeMember(bob);
 
-    expect(childGroup.getRoleOf(bob.id)).toBeUndefined();
+    expect(childGroup.getRoleOf(bob.$jazz.id)).toBeUndefined();
 
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
         role: "admin",
       }),
@@ -712,7 +917,7 @@ describe("Group.getDirectMembers", () => {
     const childGroup = Group.create();
 
     const bob = await createJazzTestAccount({});
-    await bob.waitForAllCoValuesSync();
+    await bob.$jazz.waitForAllCoValuesSync();
 
     // Add bob to parent group
     parentGroup.addMember(bob, "reader");
@@ -724,12 +929,16 @@ describe("Group.getDirectMembers", () => {
     expect(childGroup.members).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
       }),
       expect.objectContaining({
         account: expect.objectContaining({
-          id: bob.id,
+          $jazz: expect.objectContaining({
+            id: bob.$jazz.id,
+          }),
         }),
       }),
     ]);
@@ -738,7 +947,9 @@ describe("Group.getDirectMembers", () => {
     expect(childGroup.getDirectMembers()).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
       }),
     ]);
@@ -747,7 +958,9 @@ describe("Group.getDirectMembers", () => {
     expect(childGroup.getDirectMembers()).not.toContainEqual(
       expect.objectContaining({
         account: expect.objectContaining({
-          id: bob.id,
+          $jazz: expect.objectContaining({
+            id: bob.$jazz.id,
+          }),
         }),
       }),
     );
@@ -756,12 +969,16 @@ describe("Group.getDirectMembers", () => {
     expect(parentGroup.getDirectMembers()).toEqual([
       expect.objectContaining({
         account: expect.objectContaining({
-          id: co.account().getMe().id,
+          $jazz: expect.objectContaining({
+            id: co.account().getMe().$jazz.id,
+          }),
         }),
       }),
       expect.objectContaining({
         account: expect.objectContaining({
-          id: bob.id,
+          $jazz: expect.objectContaining({
+            id: bob.$jazz.id,
+          }),
         }),
       }),
     ]);