cojson 0.13.17 → 0.13.18

package/src/tests/{coValueState.test.ts → coValueCoreLoadingState.test.ts}

@@ -1,17 +1,9 @@
-import {
-  assert,
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  onTestFinished,
-  test,
-  vi,
-} from "vitest";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState";
-import { CoValueCore } from "../coValueCore";
-import { CoValueState } from "../coValueState";
+import { CoValueCore } from "../coValueCore/coValueCore";
+import { CoValueHeader, VerifiedState } from "../coValueCore/verifiedState";
 import { RawCoID } from "../ids";
+import { LocalNode } from "../localNode";
 import { Peer } from "../sync";
 import { createTestMetricReader, tearDownTestMetricReader } from "./testUtils";
 
@@ -25,14 +17,16 @@ afterEach(() => {
   tearDownTestMetricReader();
 });
 
-describe("CoValueState", () => {
+const mockNode = {} as LocalNode;
+
+describe("CoValueCore loading state", () => {
   const mockCoValueId = "co_test123" as RawCoID;
 
   test("should create unknown state", async () => {
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
 
     expect(state.id).toBe(mockCoValueId);
-    expect(state.highLevelState).toBe("unknown");
+    expect(state.loadingState).toBe("unknown");
     expect(
       await metricReader.getMetricValue("jazz.covalues.loaded", {
         state: "unknown",
@@ -41,14 +35,14 @@ describe("CoValueState", () => {
   });
 
   test("should create loading state", async () => {
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     state.loadFromPeers([
       createMockPeerState({ id: "peer1", role: "server" }),
       createMockPeerState({ id: "peer2", role: "server" }),
     ]);
 
     expect(state.id).toBe(mockCoValueId);
-    expect(state.highLevelState).toBe("loading");
+    expect(state.loadingState).toBe("loading");
     expect(
       await metricReader.getMetricValue("jazz.covalues.loaded", {
         state: "loading",
@@ -57,14 +51,16 @@ describe("CoValueState", () => {
   });
 
   test("should create available state", async () => {
-    const mockCoValue = createMockCoValueCore(mockCoValueId);
-    const state = new CoValueState(mockCoValueId);
-    state.internalMarkMagicallyAvailable(mockCoValue);
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    state.internalMarkMagicallyAvailable(mockVerified);
 
     expect(state.id).toBe(mockCoValueId);
-    expect(state.highLevelState).toBe("available");
-    expect(state.core).toBe(mockCoValue);
-    await expect(state.getCoValue()).resolves.toEqual(mockCoValue);
+    expect(state.loadingState).toBe("available");
+    expect(state.verified).toBe(mockVerified);
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: mockVerified,
+    });
     expect(
       await metricReader.getMetricValue("jazz.covalues.loaded", {
         state: "available",
@@ -73,8 +69,8 @@ describe("CoValueState", () => {
   });
 
   test("should handle found action", async () => {
-    const mockCoValue = createMockCoValueCore(mockCoValueId);
-    const state = new CoValueState(mockCoValueId);
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     state.loadFromPeers([
       createMockPeerState({ id: "peer1", role: "server" }),
       createMockPeerState({ id: "peer2", role: "server" }),
@@ -91,13 +87,15 @@ describe("CoValueState", () => {
       }),
     ).toBe(1);
 
-    const stateValuePromise = state.getCoValue();
+    const stateValuePromise = state.waitForAvailableOrUnavailable();
 
-    state.internalMarkMagicallyAvailable(mockCoValue);
+    state.internalMarkMagicallyAvailable(mockVerified);
 
-    const result = await state.getCoValue();
-    expect(result).toBe(mockCoValue);
-    await expect(stateValuePromise).resolves.toBe(mockCoValue);
+    const result = await state.waitForAvailableOrUnavailable();
+    expect(result).toMatchObject({ verified: mockVerified });
+    await expect(stateValuePromise).resolves.toMatchObject({
+      verified: mockVerified,
+    });
 
     expect(
       await metricReader.getMetricValue("jazz.covalues.loaded", {
@@ -135,17 +133,18 @@ describe("CoValueState", () => {
 
     const mockPeers = [peer1, peer2] as unknown as PeerState[];
 
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     const loadPromise = state.loadFromPeers(mockPeers);
 
     await vi.runAllTimersAsync();
-
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
-    expect(state.highLevelState).toBe("unavailable");
-    await expect(state.getCoValue()).resolves.toBe("unavailable");
+    expect(state.loadingState).toBe("unavailable");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: null,
+    });
 
     vi.useRealTimers();
   });
@@ -165,18 +164,22 @@ describe("CoValueState", () => {
 
     const mockPeers = [peer1] as unknown as PeerState[];
 
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     const loadPromise = state.loadFromPeers(mockPeers);
 
     await vi.runAllTimersAsync();
 
-    state.internalMarkMagicallyAvailable(createMockCoValueCore(mockCoValueId));
+    state.internalMarkMagicallyAvailable(
+      createMockCoValueVerified(mockCoValueId),
+    );
 
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
-    expect(state.highLevelState).toBe("available");
-    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      _verified: expect.any(Object),
+    });
 
     vi.useRealTimers();
   });
@@ -184,7 +187,7 @@ describe("CoValueState", () => {
   test("should start sending the known state to peers when available", async () => {
     vi.useFakeTimers();
 
-    const mockCoValue = createMockCoValueCore(mockCoValueId);
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
 
     const peer1 = createMockPeerState(
       {
@@ -192,7 +195,7 @@ describe("CoValueState", () => {
         role: "storage",
       },
       async () => {
-        state.markAvailable(mockCoValue, "peer1");
+        state.markAvailable({} as CoValueHeader, "peer1");
       },
     );
     const peer2 = createMockPeerState(
@@ -205,7 +208,7 @@ describe("CoValueState", () => {
       },
     );
 
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
     await vi.runAllTimersAsync();
@@ -215,10 +218,12 @@ describe("CoValueState", () => {
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledWith({
       action: "load",
-      ...mockCoValue.knownState(),
+      ...mockVerified.knownState(),
+    });
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: mockVerified,
     });
-    expect(state.highLevelState).toBe("available");
-    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
 
     vi.useRealTimers();
   });
@@ -226,7 +231,7 @@ describe("CoValueState", () => {
   test("should skip closed peers", async () => {
     vi.useFakeTimers();
 
-    const mockCoValue = createMockCoValueCore(mockCoValueId);
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
 
     const peer1 = createMockPeerState(
       {
@@ -243,13 +248,13 @@ describe("CoValueState", () => {
         role: "server",
       },
       async () => {
-        state.markAvailable(mockCoValue, "peer2");
+        state.markAvailable({} as CoValueHeader, "peer2");
       },
     );
 
     peer1.closed = true;
 
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
     await vi.runAllTimersAsync();
@@ -258,8 +263,10 @@ describe("CoValueState", () => {
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(0);
     expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
 
-    expect(state.highLevelState).toBe("available");
-    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: mockVerified,
+    });
 
     vi.useRealTimers();
   });
@@ -275,7 +282,7 @@ describe("CoValueState", () => {
       async () => {},
     );
 
-    const state = new CoValueState(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
     const loadPromise = state.loadFromPeers([peer1]);
 
     await vi.runAllTimersAsync();
@@ -283,8 +290,10 @@ describe("CoValueState", () => {
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
 
-    expect(state.highLevelState).toBe("unavailable");
-    await expect(state.getCoValue()).resolves.toEqual("unavailable");
+    expect(state.loadingState).toBe("unavailable");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: null,
+    });
 
     vi.useRealTimers();
   });
@@ -311,17 +320,18 @@ function createMockPeerState(
   return peerState;
 }
 
-function createMockCoValueCore(mockCoValueId: string) {
+function createMockCoValueVerified(mockCoValueId: string) {
   // Setting the knownState as part of the prototype to simplify
   // the equality checks
-  const mockCoValue = Object.create({
+  const mockCoValueVerified = Object.create({
+    id: mockCoValueId,
     knownState: vi.fn().mockReturnValue({
       id: mockCoValueId,
       header: true,
       sessions: {},
     }),
-  });
+    clone: vi.fn().mockReturnThis(),
+  }) as unknown as VerifiedState;
 
-  mockCoValue.id = mockCoValueId;
-  return mockCoValue as unknown as CoValueCore;
+  return mockCoValueVerified as unknown as VerifiedState;
 }

package/src/tests/group.test.ts

@@ -1,24 +1,23 @@
 import { describe, expect, test } from "vitest";
-import { CoValueState } from "../coValueState.js";
 import { RawCoList } from "../coValues/coList.js";
 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 { RawAccountID } from "../exports.js";
-import { LocalNode } from "../localNode.js";
 import {
   createThreeConnectedNodes,
   createTwoConnectedNodes,
   loadCoValueOrFail,
-  randomAnonymousAccountAndSessionID,
+  nodeWithRandomAgentAndSessionID,
+  randomAgentAndSessionID,
   waitFor,
 } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Can create a RawCoMap in a group", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const group = node.createGroup();
 
@@ -29,7 +28,7 @@ test("Can create a RawCoMap in a group", () => {
 });
 
 test("Can create a CoList in a group", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const group = node.createGroup();
 
@@ -40,7 +39,7 @@ test("Can create a CoList in a group", () => {
 });
 
 test("Can create a CoStream in a group", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const group = node.createGroup();
 
@@ -51,7 +50,7 @@ test("Can create a CoStream in a group", () => {
 });
 
 test("Can create a FileStream in a group", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const group = node.createGroup();
 
@@ -100,7 +99,7 @@ test("Remove a member from a group where the admin role is inherited", async ()
 
   // The node1 account removes the reader from the group
   // The reader should be automatically kicked out of the child group
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
 
   await group.core.waitForSync();
 
@@ -150,7 +149,7 @@ test("An admin should be able to rotate the readKey on child groups and keep acc
   // The node1 account removes the reader from the group
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
   await group.core.waitForSync();
 
   const map = childGroup.createMap();
@@ -191,7 +190,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // The node1 account removes the reader from the group
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
   await group.core.waitForSync();
 
   const map = childGroup.createMap();
@@ -234,7 +233,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // The node1 account removes the reader from the group
   // In this case we want to ensure that node1 is still able to read new coValues
   // Even if some childs are not available when the readKey is rotated
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
   await group.core.waitForSync();
 
   const map = childGroup.createMap();
@@ -268,7 +267,7 @@ test("A user add after a key rotation should have access to the old transactions
 
   await map.core.waitForSync();
 
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
   group.addMember(
     await loadCoValueOrFail(node1.node, node3.accountID),
     "reader",
@@ -295,7 +294,7 @@ test("Invites should have access to the new keys", async () => {
 
   const invite = group.createInvite("admin");
 
-  await group.removeMember(node3.node.account);
+  await group.removeMember(node3.node.expectCurrentAccount("node3"));
 
   const map = group.createMap();
   map.set("test", "Written from node1");
@@ -454,7 +453,7 @@ describe("writeOnly", () => {
 
     await map.core.waitForSync();
 
-    await group.removeMember(node3.node.account);
+    await group.removeMember(node3.node.expectCurrentAccount("node3"));
 
     await group.core.waitForSync();
 
@@ -491,10 +490,8 @@ describe("writeOnly", () => {
       "writer",
     );
 
-    node2.node.coValuesStore.coValues.delete(map.id);
-    expect(node2.node.coValuesStore.get(map.id)?.highLevelState).toBe(
-      "unknown",
-    );
+    node2.node.internalDeleteCoValue(map.id);
+    expect(node2.node.getCoValue(map.id)?.loadingState).toBe("unknown");
 
     const mapOnNode2 = await loadCoValueOrFail(node2.node, map.id);
 
@@ -918,96 +915,75 @@ describe("extend with role mapping", () => {
 
 describe("roleOf", () => {
   test("returns direct role assignments", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2] = randomAgentAndSessionID();
 
-    group.addMember(account, "writer");
-    expect(group.roleOf(account.id as RawAccountID)).toEqual("writer");
+    group.addMember(agent2, "writer");
+    expect(group.roleOfInternal(agent2.id)).toEqual("writer");
   });
 
   test("returns undefined for non-members", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2] = randomAgentAndSessionID();
 
-    expect(group.roleOf(account.id as RawAccountID)).toEqual(undefined);
+    expect(group.roleOfInternal(agent2.id)).toEqual(undefined);
   });
 
   test("revoked roles return undefined", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
-
-    group.addMember(account, "writer");
-    group.removeMemberInternal(account);
-    expect(group.roleOf(account.id as RawAccountID)).toEqual(undefined);
+    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 = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2, sessionID2] = randomAgentAndSessionID();
 
     group.addMemberInternal("everyone", "reader");
-    expect(group.roleOf(account.id as RawAccountID)).toEqual("reader");
+    expect(group.roleOfInternal(agent2.id)).toEqual("reader");
   });
 
   test("account role overrides everyone role", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2, sessionID2] = randomAgentAndSessionID();
 
     group.addMemberInternal("everyone", "writer");
-    group.addMember(account, "reader");
-    expect(group.roleOf(account.id as RawAccountID)).toEqual("reader");
+    group.addMember(agent2, "reader");
+    expect(group.roleOfInternal(agent2.id)).toEqual("reader");
   });
 
   test("Revoking access on everyone role should not affect existing members", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2, sessionID2] = randomAgentAndSessionID();
 
     group.addMemberInternal("everyone", "reader");
-    group.addMember(account, "writer");
+    group.addMember(agent2, "writer");
     group.removeMemberInternal("everyone");
-    expect(group.roleOf(account.id as RawAccountID)).toEqual("writer");
-    expect(group.roleOf("123" as RawAccountID)).toEqual(undefined);
+    expect(group.roleOfInternal(agent2.id)).toEqual("writer");
+    expect(group.roleOfInternal("123" as RawAccountID)).toEqual(undefined);
   });
 
   test("Everyone role is inherited following the most permissive algorithm", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+    const node = nodeWithRandomAgentAndSessionID();
     const group = node.createGroup();
-    const account = new LocalNode(
-      ...randomAnonymousAccountAndSessionID(),
-      Crypto,
-    ).account;
+    const [agent2, sessionID2] = randomAgentAndSessionID();
 
     const parentGroup = node.createGroup();
     parentGroup.addMemberInternal("everyone", "writer");
 
     group.extend(parentGroup);
-    group.addMember(account, "reader");
+    group.addMember(agent2, "reader");
 
-    expect(group.roleOf(account.id as RawAccountID)).toEqual("writer");
+    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");

package/src/tests/messagesTestUtils.ts

@@ -1,10 +1,5 @@
-import { CoValueCore, LocalNode, RawControlledAccount } from "../exports";
-import {
-  CoValueKnownState,
-  NewContentMessage,
-  Peer,
-  SyncMessage,
-} from "../sync";
+import { CoValueCore, LocalNode } from "../exports";
+import { CoValueKnownState, NewContentMessage, SyncMessage } from "../sync";
 
 function simplifySessions(msg: CoValueKnownState) {
   const count = Object.values(msg.sessions).reduce(
@@ -64,7 +59,7 @@ export function toSimplifiedMessages(
 }
 
 export function nodeRelatedKnownCoValues(node: LocalNode, name: string) {
-  const account = node.account as RawControlledAccount;
+  const account = node.expectCurrentAccount("relatedKnownCoValues");
   const profileID = account.get("profile");
   const profile = profileID && node.expectCoValueLoaded(profileID);
   return {