cojson 0.15.7 → 0.15.9

package/src/tests/coValueCore.test.ts

@@ -1,5 +1,13 @@
 import { encrypt } from "jazz-crypto-rs";
-import { assert, afterEach, beforeEach, expect, test, vi } from "vitest";
+import {
+  assert,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  test,
+  vi,
+} from "vitest";
 import { bytesToBase64url } from "../base64url.js";
 import { CoValueCore } from "../coValueCore/coValueCore.js";
 import { Transaction } from "../coValueCore/verifiedState.js";
@@ -512,3 +520,264 @@ test("getValidTransactions should skip private transactions with invalid JSON",
   expect(validTransactions.length).toBe(1);
   expect(validTransactions[0]?.changes).toEqual([{ hello: "world" }]);
 });
+
+describe("markErrored and isErroredInPeer", () => {
+  test("markErrored should mark a peer as errored with the provided error", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-1";
+    const testError = {
+      type: "InvalidSignature" as const,
+      id: coValue.id,
+      newSignature: "invalid-signature" as any,
+      sessionID: sessionID,
+      signerID: "test-signer" as any,
+    };
+
+    // Initially, the peer should not be errored
+    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+
+    // Mark the peer as errored
+    coValue.markErrored(peerId, testError);
+
+    // Verify the peer is now marked as errored
+    expect(coValue.isErroredInPeer(peerId)).toBe(true);
+
+    // Verify the peer state contains the error
+    const peerState = coValue.getStateForPeer(peerId);
+    expect(peerState).toBeDefined();
+    expect(peerState?.type).toBe("errored");
+  });
+
+  test("markErrored should update loading state and notify listeners", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-2";
+    const testError = {
+      type: "InvalidHash" as const,
+      id: coValue.id,
+      expectedNewHash: "expected-hash" as any,
+      givenExpectedNewHash: "given-hash" as any,
+    };
+
+    const listener = vi.fn();
+    coValue.subscribe(listener);
+
+    // Mark the peer as errored
+    coValue.markErrored(peerId, testError);
+
+    // Verify the listener was called
+    expect(listener).toHaveBeenCalled();
+  });
+
+  test("isErroredInPeer should return false for non-existent peers", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const nonExistentPeerId = "non-existent-peer";
+
+    // Verify non-existent peer is not errored
+    expect(coValue.isErroredInPeer(nonExistentPeerId)).toBe(false);
+  });
+
+  test("isErroredInPeer should return false for peers with other states", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-3";
+
+    // Mark peer as pending
+    coValue.markPending(peerId);
+    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+
+    // Mark peer as unavailable
+    coValue.markNotFoundInPeer(peerId);
+    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+
+    // Mark peer as available
+    coValue.provideHeader({} as any, peerId);
+    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+  });
+
+  test("markErrored should work with multiple peers", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peer1Id = "peer-1";
+    const peer2Id = "peer-2";
+    const peer3Id = "peer-3";
+
+    const error1 = {
+      type: "InvalidSignature" as const,
+      id: coValue.id,
+      newSignature: "invalid-signature-1" as any,
+      sessionID: sessionID,
+      signerID: "test-signer-1" as any,
+    };
+
+    const error2 = {
+      type: "InvalidHash" as const,
+      id: coValue.id,
+      expectedNewHash: "expected-hash-2" as any,
+      givenExpectedNewHash: "given-hash-2" as any,
+    };
+
+    // Mark different peers as errored
+    coValue.markErrored(peer1Id, error1);
+    coValue.markErrored(peer2Id, error2);
+
+    // Verify each peer is correctly marked as errored
+    expect(coValue.isErroredInPeer(peer1Id)).toBe(true);
+    expect(coValue.isErroredInPeer(peer2Id)).toBe(true);
+    expect(coValue.isErroredInPeer(peer3Id)).toBe(false);
+  });
+
+  test("markErrored should override previous peer states", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-4";
+
+    // Initially mark as pending
+    coValue.markPending(peerId);
+    expect(coValue.isErroredInPeer(peerId)).toBe(false);
+
+    // Then mark as errored
+    const testError = {
+      type: "TriedToAddTransactionsWithoutVerifiedState" as const,
+      id: coValue.id,
+    };
+
+    coValue.markErrored(peerId, testError);
+
+    // Verify the peer is now errored
+    expect(coValue.isErroredInPeer(peerId)).toBe(true);
+
+    const peerState = coValue.getStateForPeer(peerId);
+    expect(peerState?.type).toBe("errored");
+  });
+
+  test("markErrored should work with different error types", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-5";
+
+    // Test with InvalidSignature error
+    const invalidSignatureError = {
+      type: "InvalidSignature" as const,
+      id: coValue.id,
+      newSignature: "invalid-sig" as any,
+      sessionID: sessionID,
+      signerID: "test-signer" as any,
+    };
+
+    coValue.markErrored(peerId, invalidSignatureError);
+    expect(coValue.isErroredInPeer(peerId)).toBe(true);
+
+    // Test with InvalidHash error
+    const invalidHashError = {
+      type: "InvalidHash" as const,
+      id: coValue.id,
+      expectedNewHash: "expected" as any,
+      givenExpectedNewHash: "given" as any,
+    };
+
+    coValue.markErrored(peerId, invalidHashError);
+    expect(coValue.isErroredInPeer(peerId)).toBe(true);
+
+    // Test with TriedToAddTransactionsWithoutVerifiedState error
+    const noVerifiedStateError = {
+      type: "TriedToAddTransactionsWithoutVerifiedState" as const,
+      id: coValue.id,
+    };
+
+    coValue.markErrored(peerId, noVerifiedStateError);
+    expect(coValue.isErroredInPeer(peerId)).toBe(true);
+  });
+
+  test("markErrored should trigger immediate notification", () => {
+    const [agent, sessionID] = randomAgentAndSessionID();
+    const node = new LocalNode(agent.agentSecret, sessionID, Crypto);
+
+    const coValue = node.createCoValue({
+      type: "costream",
+      ruleset: { type: "unsafeAllowAll" },
+      meta: null,
+      ...Crypto.createdNowUnique(),
+    });
+
+    const peerId = "test-peer-6";
+    const testError = {
+      type: "InvalidSignature" as const,
+      id: coValue.id,
+      newSignature: "test-sig" as any,
+      sessionID: sessionID,
+      signerID: "test-signer" as any,
+    };
+
+    let notificationCount = 0;
+    const listener = () => {
+      notificationCount++;
+    };
+
+    coValue.subscribe(listener);
+
+    // Mark as errored
+    coValue.markErrored(peerId, testError);
+
+    // Verify immediate notification
+    expect(notificationCount).toBeGreaterThan(0);
+  });
+});

package/src/tests/coValueCoreLoadingState.test.ts

@@ -192,7 +192,7 @@ describe("CoValueCore loading state", () => {
     const peer1 = createMockPeerState(
       {
         id: "peer1",
-        role: "storage",
+        role: "server",
       },
       async () => {
         state.provideHeader({} as CoValueHeader, "peer1");
@@ -236,7 +236,7 @@ describe("CoValueCore loading state", () => {
     const peer1 = createMockPeerState(
       {
         id: "peer1",
-        role: "storage",
+        role: "server",
       },
       async () => {
         return new Promise(() => {});

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

@@ -2,6 +2,7 @@ import { beforeEach, describe, expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
 import {
   SyncMessagesLog,
+  TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,

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

@@ -1,19 +1,13 @@
 import { beforeEach, describe, expect, test } from "vitest";
-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 {
   SyncMessagesLog,
-  createTwoConnectedNodes,
+  TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestAccount,
   setupTestNode,
 } from "./testUtils.js";
 
-let jazzCloud = setupTestNode({ isSyncServer: true });
+let jazzCloud: ReturnType<typeof setupTestNode>;
 
 beforeEach(async () => {
   SyncMessagesLog.clear();

package/src/tests/messagesTestUtils.ts

@@ -1,7 +1,7 @@
 import { CoValueCore, LocalNode } from "../exports";
 import { CoValueKnownState, NewContentMessage, SyncMessage } from "../sync";
 
-function simplifySessions(msg: CoValueKnownState) {
+function simplifySessions(msg: Pick<CoValueKnownState, "sessions" | "header">) {
   const count = Object.values(msg.sessions).reduce(
     (acc, session) => acc + session,
     0,
@@ -51,7 +51,7 @@ export function toSimplifiedMessages(
       case "done":
         return `${from} -> ${to} | DONE ${getCoValue(msg.id)}`;
       case "content":
-        return `${from} -> ${to} | CONTENT ${getCoValue(msg.id)} header: ${Boolean(msg.header)} new: ${simplifyNewContent(msg.new)}`;
+        return `${from} -> ${to} | CONTENT ${getCoValue(msg.id)} header: ${Boolean(msg.header)} new: ${simplifyNewContent(msg.new)}${msg.expectContentUntil ? ` expectContentUntil: ${simplifySessions({ sessions: msg.expectContentUntil, header: true })}` : ""}`;
     }
   }
 

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

@@ -4,12 +4,16 @@ import { WasmCrypto } from "../crypto/WasmCrypto";
 import { LocalNode } from "../localNode";
 import {
   SyncMessagesLog,
+  TEST_NODE_CONFIG,
   getSyncServerConnectedPeer,
   setupTestNode,
 } from "./testUtils";
 
 const Crypto = await WasmCrypto.create();
-let jazzCloud = setupTestNode({ isSyncServer: true });
+let jazzCloud: ReturnType<typeof setupTestNode>;
+
+// We want to simulate a real world communication that happens asynchronously
+TEST_NODE_CONFIG.withAsyncPeers = true;
 
 beforeEach(async () => {
   SyncMessagesLog.clear();
@@ -50,10 +54,10 @@ describe("LocalNode auth sync", () => {
     ).toMatchInlineSnapshot(`
       [
         "client -> server | CONTENT Account header: true new: After: 0 New: 4",
-        "server -> client | KNOWN Account sessions: header/4",
         "client -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
-        "server -> client | KNOWN ProfileGroup sessions: header/5",
         "client -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Account sessions: header/4",
+        "server -> client | KNOWN ProfileGroup sessions: header/5",
         "server -> client | KNOWN Profile sessions: header/1",
       ]
     `);
@@ -111,10 +115,10 @@ describe("LocalNode auth sync", () => {
     ).toMatchInlineSnapshot(`
       [
         "client -> server | CONTENT Account header: true new: After: 0 New: 5",
-        "server -> client | KNOWN Account sessions: header/5",
         "client -> server | CONTENT Root header: true new: After: 0 New: 1",
-        "server -> client | KNOWN Root sessions: header/1",
         "client -> server | CONTENT Profile header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Account sessions: header/5",
+        "server -> client | KNOWN Root sessions: header/1",
         "server -> client | KNOWN Profile sessions: header/1",
       ]
     `);
@@ -165,18 +169,18 @@ describe("LocalNode auth sync", () => {
     ).toMatchInlineSnapshot(`
       [
         "creation-node -> server | CONTENT Account header: true new: After: 0 New: 4",
+        "creation-node -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "creation-node -> server | CONTENT Profile header: true new: After: 0 New: 1",
         "auth-node -> server | LOAD Account sessions: empty",
         "server -> creation-node | KNOWN Account sessions: header/4",
-        "creation-node -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
-        "server -> auth-node | CONTENT Account header: true new: After: 0 New: 4",
         "server -> creation-node | KNOWN ProfileGroup sessions: header/5",
-        "creation-node -> server | CONTENT Profile header: true new: After: 0 New: 1",
-        "auth-node -> server | KNOWN Account sessions: header/4",
         "server -> creation-node | KNOWN Profile sessions: header/1",
+        "server -> auth-node | CONTENT Account header: true new: After: 0 New: 4",
+        "auth-node -> server | KNOWN Account sessions: header/4",
         "auth-node -> server | LOAD Profile sessions: empty",
         "server -> auth-node | CONTENT ProfileGroup header: true new: After: 0 New: 5",
-        "auth-node -> server | KNOWN ProfileGroup sessions: header/5",
         "server -> auth-node | CONTENT Profile header: true new: After: 0 New: 1",
+        "auth-node -> server | KNOWN ProfileGroup sessions: header/5",
         "auth-node -> server | KNOWN Profile sessions: header/1",
       ]
     `);
@@ -200,6 +204,7 @@ describe("LocalNode auth sync", () => {
       crypto: Crypto,
     });
 
+    await creationNode.syncManager.waitForAllCoValuesSync();
     creationNode.gracefulShutdown();
 
     const { peer: existingAccountPeer } = getSyncServerConnectedPeer({
@@ -232,14 +237,19 @@ describe("LocalNode auth sync", () => {
     ).toMatchInlineSnapshot(`
       [
         "creation-node -> server | CONTENT Account header: true new: After: 0 New: 4",
-        "auth-node -> server | LOAD Account sessions: empty",
+        "creation-node -> server | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "creation-node -> server | CONTENT Profile header: true new: After: 0 New: 1",
         "server -> creation-node | KNOWN Account sessions: header/4",
+        "server -> creation-node | KNOWN ProfileGroup sessions: header/5",
+        "server -> creation-node | KNOWN Profile sessions: header/1",
+        "auth-node -> server | LOAD Account sessions: empty",
         "server -> auth-node | CONTENT Account header: true new: After: 0 New: 4",
         "auth-node -> server | KNOWN Account sessions: header/4",
         "auth-node -> server | LOAD Profile sessions: empty",
-        "server -> auth-node | KNOWN Profile sessions: empty",
-        "auth-node -> server | LOAD Profile sessions: empty",
-        "server -> auth-node | KNOWN Profile sessions: empty",
+        "server -> auth-node | CONTENT ProfileGroup header: true new: After: 0 New: 5",
+        "server -> auth-node | CONTENT Profile header: true new: After: 0 New: 1",
+        "auth-node -> server | KNOWN ProfileGroup sessions: header/5",
+        "auth-node -> server | KNOWN Profile sessions: header/1",
       ]
     `);
   });

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

@@ -1,16 +1,16 @@
 import { beforeEach, describe, expect, test } from "vitest";
 
-import { expectList, expectMap } from "../coValue";
-import { WasmCrypto } from "../crypto/WasmCrypto";
 import {
   SyncMessagesLog,
+  TEST_NODE_CONFIG,
   loadCoValueOrFail,
   setupTestNode,
-  waitFor,
 } from "./testUtils";
 
-const Crypto = await WasmCrypto.create();
-let jazzCloud = setupTestNode({ isSyncServer: true });
+// We want to simulate a real world communication that happens asynchronously
+TEST_NODE_CONFIG.withAsyncPeers = true;
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
 
 beforeEach(async () => {
   SyncMessagesLog.clear();
@@ -53,13 +53,10 @@ describe("invitations sync", () => {
       [
         "invite-consumer -> server | LOAD Map sessions: empty",
         "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 5",
-        "invite-consumer -> server | KNOWN Group sessions: header/5",
         "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-consumer -> server | KNOWN Group sessions: header/5",
         "invite-consumer -> server | KNOWN Map sessions: header/1",
         "invite-consumer -> server | CONTENT Group header: false new: After: 0 New: 2",
-        "server -> invite-consumer | KNOWN Group sessions: header/7",
-        "server -> invite-provider | CONTENT Group header: false new: After: 0 New: 2",
-        "invite-provider -> server | KNOWN Group sessions: header/7",
       ]
     `);
   });
@@ -103,15 +100,12 @@ describe("invitations sync", () => {
       [
         "invite-consumer -> server | LOAD Map sessions: empty",
         "server -> invite-consumer | CONTENT ParentGroup header: true new: After: 0 New: 4",
-        "invite-consumer -> server | KNOWN ParentGroup sessions: header/4",
         "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 7",
-        "invite-consumer -> server | KNOWN Group sessions: header/7",
         "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-consumer -> server | KNOWN ParentGroup sessions: header/4",
+        "invite-consumer -> server | KNOWN Group sessions: header/7",
         "invite-consumer -> server | KNOWN Map sessions: header/1",
         "invite-consumer -> server | CONTENT Group header: false new: After: 0 New: 2",
-        "server -> invite-consumer | KNOWN Group sessions: header/9",
-        "server -> invite-provider | CONTENT Group header: false new: After: 0 New: 2",
-        "invite-provider -> server | KNOWN Group sessions: header/9",
       ]
     `);
   });
@@ -157,13 +151,13 @@ describe("invitations sync", () => {
         "server -> invite-consumer | CONTENT ParentGroup header: true new: After: 0 New: 6",
         "invite-consumer -> server | KNOWN ParentGroup sessions: header/6",
         "invite-consumer -> server | CONTENT ParentGroup header: false new: After: 0 New: 2",
+        "invite-consumer -> server | LOAD Map sessions: empty",
         "server -> invite-consumer | KNOWN ParentGroup sessions: header/8",
         "server -> invite-provider | CONTENT ParentGroup header: false new: After: 0 New: 2",
-        "invite-consumer -> server | LOAD Map sessions: empty",
-        "invite-provider -> server | KNOWN ParentGroup sessions: header/8",
         "server -> invite-consumer | CONTENT Group header: true new: After: 0 New: 5",
-        "invite-consumer -> server | KNOWN Group sessions: header/5",
         "server -> invite-consumer | CONTENT Map header: true new: After: 0 New: 1",
+        "invite-provider -> server | KNOWN ParentGroup sessions: header/8",
+        "invite-consumer -> server | KNOWN Group sessions: header/5",
         "invite-consumer -> server | KNOWN Map sessions: header/1",
       ]
     `);