cojson 0.13.16 → 0.13.18

package/src/tests/coValueCoreLoadingState.test.ts

@@ -0,0 +1,337 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { PeerState } from "../PeerState";
+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";
+
+let metricReader: ReturnType<typeof createTestMetricReader>;
+
+beforeEach(() => {
+  metricReader = createTestMetricReader();
+});
+
+afterEach(() => {
+  tearDownTestMetricReader();
+});
+
+const mockNode = {} as LocalNode;
+
+describe("CoValueCore loading state", () => {
+  const mockCoValueId = "co_test123" as RawCoID;
+
+  test("should create unknown state", async () => {
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+
+    expect(state.id).toBe(mockCoValueId);
+    expect(state.loadingState).toBe("unknown");
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "unknown",
+      }),
+    ).toBe(1);
+  });
+
+  test("should create loading state", async () => {
+    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.loadingState).toBe("loading");
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(1);
+  });
+
+  test("should create available state", async () => {
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    state.internalMarkMagicallyAvailable(mockVerified);
+
+    expect(state.id).toBe(mockCoValueId);
+    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",
+      }),
+    ).toBe(1);
+  });
+
+  test("should handle found action", async () => {
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    state.loadFromPeers([
+      createMockPeerState({ id: "peer1", role: "server" }),
+      createMockPeerState({ id: "peer2", role: "server" }),
+    ]);
+
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "available",
+      }),
+    ).toBe(undefined);
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(1);
+
+    const stateValuePromise = state.waitForAvailableOrUnavailable();
+
+    state.internalMarkMagicallyAvailable(mockVerified);
+
+    const result = await state.waitForAvailableOrUnavailable();
+    expect(result).toMatchObject({ verified: mockVerified });
+    await expect(stateValuePromise).resolves.toMatchObject({
+      verified: mockVerified,
+    });
+
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "available",
+      }),
+    ).toBe(1);
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(0);
+  });
+
+  test("should skip errored coValues when loading from peers", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        state.markErrored("peer1", {} as any);
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.markNotFoundInPeer("peer2");
+      },
+    );
+
+    const mockPeers = [peer1, peer2] as unknown as PeerState[];
+
+    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.loadingState).toBe("unavailable");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: null,
+    });
+
+    vi.useRealTimers();
+  });
+
+  test("should have a coValue as value property when becomes available after that have been marked as unavailable", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {
+        state.markNotFoundInPeer("peer1");
+      },
+    );
+
+    const mockPeers = [peer1] as unknown as PeerState[];
+
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    const loadPromise = state.loadFromPeers(mockPeers);
+
+    await vi.runAllTimersAsync();
+
+    state.internalMarkMagicallyAvailable(
+      createMockCoValueVerified(mockCoValueId),
+    );
+
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      _verified: expect.any(Object),
+    });
+
+    vi.useRealTimers();
+  });
+
+  test("should start sending the known state to peers when available", async () => {
+    vi.useFakeTimers();
+
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "storage",
+      },
+      async () => {
+        state.markAvailable({} as CoValueHeader, "peer1");
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.markNotFoundInPeer("peer2");
+      },
+    );
+
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    const loadPromise = state.loadFromPeers([peer1, peer2]);
+
+    await vi.runAllTimersAsync();
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledWith({
+      action: "load",
+      ...mockVerified.knownState(),
+    });
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: mockVerified,
+    });
+
+    vi.useRealTimers();
+  });
+
+  test("should skip closed peers", async () => {
+    vi.useFakeTimers();
+
+    const mockVerified = createMockCoValueVerified(mockCoValueId);
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "storage",
+      },
+      async () => {
+        return new Promise(() => {});
+      },
+    );
+    const peer2 = createMockPeerState(
+      {
+        id: "peer2",
+        role: "server",
+      },
+      async () => {
+        state.markAvailable({} as CoValueHeader, "peer2");
+      },
+    );
+
+    peer1.closed = true;
+
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    const loadPromise = state.loadFromPeers([peer1, peer2]);
+
+    await vi.runAllTimersAsync();
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(0);
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+
+    expect(state.loadingState).toBe("available");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: mockVerified,
+    });
+
+    vi.useRealTimers();
+  });
+
+  test("should not be stuck in loading state when not getting a response", async () => {
+    vi.useFakeTimers();
+
+    const peer1 = createMockPeerState(
+      {
+        id: "peer1",
+        role: "server",
+      },
+      async () => {},
+    );
+
+    const state = CoValueCore.fromID(mockCoValueId, mockNode);
+    const loadPromise = state.loadFromPeers([peer1]);
+
+    await vi.runAllTimersAsync();
+    await loadPromise;
+
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
+
+    expect(state.loadingState).toBe("unavailable");
+    await expect(state.waitForAvailableOrUnavailable()).resolves.toMatchObject({
+      verified: null,
+    });
+
+    vi.useRealTimers();
+  });
+});
+
+function createMockPeerState(
+  peer: Partial<Peer>,
+  pushFn = () => Promise.resolve(),
+) {
+  const peerState = new PeerState(
+    {
+      id: "peer",
+      role: "server",
+      outgoing: {
+        push: pushFn,
+      },
+      ...peer,
+    } as Peer,
+    undefined,
+  );
+
+  vi.spyOn(peerState, "pushOutgoingMessage").mockImplementation(pushFn);
+
+  return peerState;
+}
+
+function createMockCoValueVerified(mockCoValueId: string) {
+  // Setting the knownState as part of the prototype to simplify
+  // the equality checks
+  const mockCoValueVerified = Object.create({
+    id: mockCoValueId,
+    knownState: vi.fn().mockReturnValue({
+      id: mockCoValueId,
+      header: true,
+      sessions: {},
+    }),
+    clone: vi.fn().mockReturnThis(),
+  }) as unknown as VerifiedState;
+
+  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 {