cojson 0.15.7 → 0.15.9

package/src/tests/PeerState.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { ConnectedPeerChannel } from "../streamUtils.js";
 import { CoValueKnownState, Peer, SyncMessage } from "../sync.js";
 import { waitFor } from "./testUtils.js";
 
@@ -9,13 +10,12 @@ function setup() {
     id: "test-peer",
     role: "client",
     priority: 1,
-    crashOnClose: false,
-    incoming: (async function* () {})(),
-    outgoing: {
-      push: vi.fn().mockResolvedValue(undefined),
-      close: vi.fn(),
-    },
+    incoming: new ConnectedPeerChannel(),
+    outgoing: new ConnectedPeerChannel(),
   };
+  vi.spyOn(mockPeer.outgoing, "push");
+  vi.spyOn(mockPeer.incoming, "close");
+  vi.spyOn(mockPeer.outgoing, "close");
   const peerState = new PeerState(mockPeer, undefined);
   return { mockPeer, peerState };
 }
@@ -38,15 +38,6 @@ describe("PeerState", () => {
     expect(peerState.incoming).toBe(mockPeer.incoming);
   });
 
-  test("should return Disconnected when closed", async () => {
-    const { peerState } = setup();
-    peerState.gracefulShutdown();
-    const incomingIterator = peerState.incoming[Symbol.asyncIterator]();
-    const { value, done } = await incomingIterator.next();
-    expect(value).toBe("Disconnected");
-    expect(done).toBe(false);
-  });
-
   test("should perform graceful shutdown", () => {
     const { mockPeer, peerState } = setup();
     peerState.gracefulShutdown();
@@ -54,109 +45,6 @@ describe("PeerState", () => {
     expect(peerState.closed).toBe(true);
   });
 
-  test("should empty the queue when closing", async () => {
-    const { mockPeer, peerState } = setup();
-
-    mockPeer.outgoing.push = vi.fn().mockImplementation((message) => {
-      return new Promise<void>((resolve) => {
-        setTimeout(resolve, 100);
-      });
-    });
-
-    peerState.pushOutgoingMessage({
-      action: "content",
-      id: "co_z1",
-      new: {},
-      priority: CO_VALUE_PRIORITY.HIGH,
-    });
-    peerState.pushOutgoingMessage({
-      action: "content",
-      id: "co_z1",
-      new: {},
-      priority: CO_VALUE_PRIORITY.HIGH,
-    });
-    peerState.pushOutgoingMessage({
-      action: "content",
-      id: "co_z1",
-      new: {},
-      priority: CO_VALUE_PRIORITY.HIGH,
-    });
-
-    peerState.gracefulShutdown();
-
-    await waitFor(() => {
-      expect(peerState.isProcessing()).toBe(false);
-    });
-
-    expect(mockPeer.outgoing.push).toHaveBeenCalledTimes(1);
-  });
-
-  test("should schedule outgoing messages based on their priority", async () => {
-    const { peerState, mockPeer } = setup();
-
-    mockPeer.outgoing.push = vi.fn().mockImplementation((message) => {
-      return new Promise<void>((resolve) => {
-        setTimeout(resolve, 0);
-      });
-    });
-
-    const loadMessage: SyncMessage = {
-      action: "load",
-      id: "co_zhigh",
-      header: false,
-      sessions: {},
-    };
-    const contentMessageHigh: SyncMessage = {
-      action: "content",
-      id: "co_zhigh",
-      new: {},
-      priority: CO_VALUE_PRIORITY.HIGH,
-    };
-    const contentMessageMid: SyncMessage = {
-      action: "content",
-      id: "co_zmid",
-      new: {},
-      priority: CO_VALUE_PRIORITY.MEDIUM,
-    };
-    const contentMessageLow: SyncMessage = {
-      action: "content",
-      id: "co_zlow",
-      new: {},
-      priority: CO_VALUE_PRIORITY.LOW,
-    };
-
-    peerState.pushOutgoingMessage(contentMessageLow);
-    peerState.pushOutgoingMessage(contentMessageMid);
-    peerState.pushOutgoingMessage(contentMessageHigh);
-    peerState.pushOutgoingMessage(loadMessage);
-
-    await waitFor(() => {
-      expect(peerState.isProcessing()).toBe(false);
-    });
-
-    // The first message is pushed directly, the other three are queued because are waiting
-    // for the first push to be completed.
-    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
-      1,
-      contentMessageLow,
-    );
-
-    // Load message are managed as high priority messages and having the same priority as the content message
-    // they follow the push order.
-    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
-      2,
-      contentMessageHigh,
-    );
-    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
-      3,
-      loadMessage,
-    );
-    expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(
-      4,
-      contentMessageMid,
-    );
-  });
-
   test("should clone the knownStates into optimisticKnownStates and knownStates when passed as argument", () => {
     const { peerState, mockPeer } = setup();
     peerState.setKnownState("co_z1", {

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -9,7 +9,11 @@ import {
 
 function setup(attrs?: Record<string, string | number>) {
   const metricReader = createTestMetricReader();
-  const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM, attrs);
+  const queue = new PriorityBasedMessageQueue(
+    CO_VALUE_PRIORITY.MEDIUM,
+    "outgoing",
+    attrs,
+  );
   return { queue, metricReader };
 }
 
@@ -29,21 +33,21 @@ describe("PriorityBasedMessageQueue", () => {
       };
 
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(0);
 
       void queue.push(message);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(1);
 
       void queue.push(message);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(2);
@@ -59,14 +63,14 @@ describe("PriorityBasedMessageQueue", () => {
       };
 
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(0);
 
       void queue.push(message);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(0);
@@ -74,7 +78,7 @@ describe("PriorityBasedMessageQueue", () => {
       void queue.pull();
 
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(1);
@@ -82,7 +86,7 @@ describe("PriorityBasedMessageQueue", () => {
       // We only have one item in the queue, so this should not change the metric value
       void queue.pull();
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
         }),
       ).toBe(1);
@@ -98,13 +102,13 @@ describe("PriorityBasedMessageQueue", () => {
       };
 
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "server",
         }),
       ).toBe(0);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "client",
         }),
@@ -112,13 +116,13 @@ describe("PriorityBasedMessageQueue", () => {
 
       void queue.push(message);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "server",
         }),
       ).toBe(1);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "server",
         }),
@@ -127,13 +131,13 @@ describe("PriorityBasedMessageQueue", () => {
       void queue.pull();
 
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pushed", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pushed", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "server",
         }),
       ).toBe(1);
       expect(
-        await metricReader.getMetricValue("jazz.messagequeue.pulled", {
+        await metricReader.getMetricValue("jazz.messagequeue.outgoing.pulled", {
           priority: CO_VALUE_PRIORITY.MEDIUM,
           role: "server",
         }),

package/src/tests/StoreQueue.test.ts

@@ -0,0 +1,283 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { StoreQueue } from "../storage/StoreQueue.js";
+import type { CoValueKnownState, NewContentMessage } from "../sync.js";
+
+function createMockNewContentMessage(id: string): NewContentMessage[] {
+  return [
+    {
+      action: "content",
+      id: id as any,
+      priority: 0,
+      new: {},
+    },
+  ];
+}
+
+function setup() {
+  const storeQueue = new StoreQueue();
+  const mockCallback = vi.fn();
+  const mockCorrectionCallback = vi.fn();
+
+  return { storeQueue, mockCallback, mockCorrectionCallback };
+}
+
+describe("StoreQueue", () => {
+  describe("push and pull", () => {
+    test("should push and pull entries in FIFO order", () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const data1 = createMockNewContentMessage("co1");
+      const data2 = createMockNewContentMessage("co2");
+
+      storeQueue.push(data1, mockCorrectionCallback);
+      storeQueue.push(data2, mockCorrectionCallback);
+
+      const entry1 = storeQueue.pull();
+      const entry2 = storeQueue.pull();
+      const entry3 = storeQueue.pull(); // Should be undefined
+
+      expect(entry1).toEqual({
+        data: data1,
+        correctionCallback: mockCorrectionCallback,
+      });
+      expect(entry2).toEqual({
+        data: data2,
+        correctionCallback: mockCorrectionCallback,
+      });
+      expect(entry3).toBeUndefined();
+    });
+
+    test("should handle empty queue", () => {
+      const { storeQueue } = setup();
+      const entry = storeQueue.pull();
+      expect(entry).toBeUndefined();
+    });
+
+    test("should handle single entry", () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+      const entry = storeQueue.pull();
+
+      expect(entry).toEqual({
+        data,
+        correctionCallback: mockCorrectionCallback,
+      });
+      expect(storeQueue.pull()).toBeUndefined();
+    });
+  });
+
+  describe("processQueue", () => {
+    test("should process all entries in queue", async () => {
+      const { storeQueue, mockCallback, mockCorrectionCallback } = setup();
+      const data1 = createMockNewContentMessage("co1");
+      const data2 = createMockNewContentMessage("co2");
+
+      storeQueue.push(data1, mockCorrectionCallback);
+      storeQueue.push(data2, mockCorrectionCallback);
+
+      await storeQueue.processQueue(mockCallback);
+
+      expect(mockCallback).toHaveBeenCalledTimes(2);
+      expect(mockCallback).toHaveBeenNthCalledWith(
+        1,
+        data1,
+        mockCorrectionCallback,
+      );
+      expect(mockCallback).toHaveBeenNthCalledWith(
+        2,
+        data2,
+        mockCorrectionCallback,
+      );
+    });
+
+    test("should not process if already processing", async () => {
+      const { storeQueue, mockCallback, mockCorrectionCallback } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      // Start processing
+      const processPromise1 = storeQueue.processQueue(mockCallback);
+
+      // Try to process again while already processing
+      const processPromise2 = storeQueue.processQueue(mockCallback);
+
+      await Promise.all([processPromise1, processPromise2]);
+
+      // Should only be called once
+      expect(mockCallback).toHaveBeenCalledTimes(1);
+    });
+
+    test("should process entries pushed after a first processing round is done", async () => {
+      const { storeQueue, mockCallback, mockCorrectionCallback } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      await storeQueue.processQueue(mockCallback);
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      await storeQueue.processQueue(mockCallback);
+
+      expect(mockCallback).toHaveBeenCalledTimes(2);
+    });
+
+    test("should handle empty queue during processing", async () => {
+      const { storeQueue, mockCallback } = setup();
+      await storeQueue.processQueue(mockCallback);
+
+      expect(mockCallback).not.toHaveBeenCalled();
+      expect(storeQueue.processing).toBe(false);
+    });
+
+    test("should handle async callback that throws", async () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      const errorCallback = vi.fn().mockRejectedValue(new Error("Test error"));
+
+      await storeQueue.processQueue(errorCallback);
+      expect(storeQueue.processing).toBe(false);
+    });
+  });
+
+  describe("drain", () => {
+    test("should remove all entries from queue", () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const data1 = createMockNewContentMessage("co1");
+      const data2 = createMockNewContentMessage("co2");
+
+      storeQueue.push(data1, mockCorrectionCallback);
+      storeQueue.push(data2, mockCorrectionCallback);
+
+      storeQueue.drain();
+
+      expect(storeQueue.pull()).toBeUndefined();
+    });
+
+    test("should handle empty queue", () => {
+      const { storeQueue } = setup();
+      expect(() => storeQueue.drain()).not.toThrow();
+      expect(storeQueue.pull()).toBeUndefined();
+    });
+  });
+
+  describe("integration scenarios", () => {
+    test("should handle complex workflow with multiple operations", async () => {
+      const { storeQueue, mockCallback, mockCorrectionCallback } = setup();
+      const data1 = createMockNewContentMessage("co1");
+      const data2 = createMockNewContentMessage("co2");
+
+      // Push entries
+      storeQueue.push(data1, mockCorrectionCallback);
+      storeQueue.push(data2, mockCorrectionCallback);
+
+      // Process queue
+      await storeQueue.processQueue(mockCallback);
+
+      // Verify all entries were processed
+      expect(mockCallback).toHaveBeenCalledTimes(2);
+      expect(storeQueue.pull()).toBeUndefined();
+
+      // Add more entries and process again
+      const data3 = createMockNewContentMessage("co3");
+      storeQueue.push(data3, mockCorrectionCallback);
+
+      await storeQueue.processQueue(mockCallback);
+
+      expect(mockCallback).toHaveBeenCalledTimes(3);
+      expect(mockCallback).toHaveBeenLastCalledWith(
+        data3,
+        mockCorrectionCallback,
+      );
+    });
+
+    test("should handle correction callback with known state", async () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const sessionId = "account1_session_z123" as any;
+      const knownState: CoValueKnownState = {
+        id: "co1" as any,
+        header: true,
+        sessions: { [sessionId]: 5 },
+      };
+
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      await storeQueue.processQueue(async (data, correctionCallback) => {
+        // Simulate some processing
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        // Call the correction callback
+        correctionCallback(knownState);
+      });
+
+      expect(mockCorrectionCallback).toHaveBeenCalledWith(knownState);
+    });
+
+    test("should handle concurrent processing attempts", async () => {
+      const { storeQueue, mockCallback, mockCorrectionCallback } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      storeQueue.push(data, mockCorrectionCallback);
+
+      // Start multiple processing attempts concurrently
+      const promises = [
+        storeQueue.processQueue(mockCallback),
+        storeQueue.processQueue(mockCallback),
+        storeQueue.processQueue(mockCallback),
+      ];
+
+      await Promise.all(promises);
+
+      // Should only process once
+      expect(mockCallback).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("edge cases", () => {
+    test("should handle undefined data", () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const data: NewContentMessage[] = [];
+      storeQueue.push(data, mockCorrectionCallback);
+
+      const entry = storeQueue.pull();
+      expect(entry).toEqual({
+        data,
+        correctionCallback: mockCorrectionCallback,
+      });
+    });
+
+    test("should handle null correction callback", () => {
+      const { storeQueue } = setup();
+      const data = createMockNewContentMessage("co1");
+
+      const nullCallback = () => {};
+      storeQueue.push(data, nullCallback);
+
+      const entry = storeQueue.pull();
+      expect(entry).toEqual({ data, correctionCallback: nullCallback });
+    });
+
+    test("should handle very large number of entries", () => {
+      const { storeQueue, mockCorrectionCallback } = setup();
+      const entries = 1000;
+
+      for (let i = 0; i < entries; i++) {
+        const data = createMockNewContentMessage(`co${i}`);
+        storeQueue.push(data, mockCorrectionCallback);
+      }
+
+      let count = 0;
+      while (storeQueue.pull()) {
+        count++;
+      }
+
+      expect(count).toBe(entries);
+    });
+  });
+});

package/src/tests/SyncStateManager.test.ts

@@ -11,8 +11,11 @@ import {
   setupTestNode,
   waitFor,
 } from "./testUtils.js";
+import { TEST_NODE_CONFIG } from "./testUtils.js";
 
-let jazzCloud = setupTestNode({ isSyncServer: true });
+TEST_NODE_CONFIG.withAsyncPeers = true;
+
+let jazzCloud: ReturnType<typeof setupTestNode>;
 
 beforeEach(async () => {
   SyncMessagesLog.clear();

package/src/tests/account.test.ts

@@ -3,7 +3,7 @@ import { expectAccount } from "../coValues/account.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
-import { createMockStoragePeer } from "./testUtils.js";
+import { createAsyncStorage } from "./testStorage.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -89,23 +89,22 @@ test("throws an error if the user tried to create an invite from an account", as
 });
 
 test("wait for storage sync before resolving withNewlyCreatedAccount", async () => {
-  const { storage, peer } = createMockStoragePeer({
-    peerId: "account-node",
+  const storage = await createAsyncStorage({
+    nodeName: "account-node",
+    storageName: "storage",
   });
 
-  const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
+  const { accountID, node } = await LocalNode.withNewlyCreatedAccount({
     creationProps: { name: "Hermes Puggington" },
     crypto: Crypto,
-    peersToLoadFrom: [peer],
+    storage,
   });
 
-  const account = storage.getCoValue(accountID);
-
-  expect(account.isAvailable()).toBe(true);
+  expect(storage.getKnownState(accountID).header).toBe(true);
 
-  const profile = storage.getCoValue(
-    expectAccount(account.getCurrentContent()).get("profile")!,
-  );
+  const profileId = expectAccount(
+    node.getCoValue(accountID).getCurrentContent(),
+  ).get("profile")!;
 
-  expect(profile.isAvailable()).toBe(true);
+  expect(storage.getKnownState(profileId).header).toBe(true);
 });

package/src/tests/coStream.test.ts

@@ -1,19 +1,17 @@
 import { beforeEach, describe, expect, test } from "vitest";
 import { expectStream } from "../coValue.js";
-import { MAX_RECOMMENDED_TX_SIZE } from "../coValueCore/coValueCore.js";
 import {
   BinaryStreamItem,
   CoStreamItem,
   RawBinaryCoStream,
   RawCoStreamView,
 } from "../coValues/coStream.js";
+import { MAX_RECOMMENDED_TX_SIZE } from "../config.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { SessionID } from "../ids.js";
-import { LocalNode } from "../localNode.js";
 import {
   loadCoValueOrFail,
   nodeWithRandomAgentAndSessionID,
-  randomAgentAndSessionID,
   setupTestNode,
   waitFor,
 } from "./testUtils.js";