cojson 0.8.38 → 0.8.39

package/src/tests/PeerState.test.ts

@@ -188,4 +188,53 @@ describe("PeerState", () => {
     expect(knownStatesSpy).toHaveBeenCalledWith(action);
     expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
   });
+
+  test("should use same reference for knownStates and optimisticKnownStates for storage peers", () => {
+    const mockStoragePeer: Peer = {
+      id: "test-storage-peer",
+      role: "storage",
+      priority: 1,
+      crashOnClose: false,
+      incoming: (async function* () {})(),
+      outgoing: {
+        push: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn(),
+      },
+    };
+    const peerState = new PeerState(mockStoragePeer, undefined);
+
+    // Verify they are the same reference
+    expect(peerState.knownStates).toBe(peerState.optimisticKnownStates);
+
+    // Verify that dispatching only updates one state
+    const knownStatesSpy = vi.spyOn(peerState.knownStates, "dispatch");
+    const optimisticKnownStatesSpy = vi.spyOn(
+      peerState.optimisticKnownStates,
+      "dispatch",
+    );
+
+    const action: PeerKnownStateActions = {
+      type: "SET",
+      id: "co_z1",
+      value: {
+        id: "co_z1",
+        header: false,
+        sessions: {},
+      },
+    };
+    peerState.dispatchToKnownStates(action);
+
+    // Only one dispatch should happen since they're the same reference
+    expect(knownStatesSpy).toHaveBeenCalledTimes(1);
+    expect(knownStatesSpy).toHaveBeenCalledWith(action);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledTimes(1);
+    expect(optimisticKnownStatesSpy).toHaveBeenCalledWith(action);
+  });
+
+  test("should use separate references for knownStates and optimisticKnownStates for non-storage peers", () => {
+    const { peerState } = setup(); // Uses a regular peer
+
+    // Verify they are different references
+    expect(peerState.knownStates).not.toBe(peerState.optimisticKnownStates);
+  });
 });

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -1,88 +1,21 @@
-import { metrics } from "@opentelemetry/api";
-import {
-  AggregationTemporality,
-  InMemoryMetricExporter,
-  MeterProvider,
-  MetricReader,
-  type MetricReaderOptions,
-  type PushMetricExporter,
-} from "@opentelemetry/sdk-metrics";
 import { afterEach, describe, expect, test } from "vitest";
 import { PriorityBasedMessageQueue } from "../PriorityBasedMessageQueue.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
 import type { SyncMessage } from "../sync.js";
-
-interface A extends MetricReaderOptions {
-  exporter: PushMetricExporter;
-}
-
-/**
- * This is a test metric reader that uses an in-memory metric exporter and exposes a method to get the value of a metric given its name and attributes.
- *
- * This is useful for testing the values of metrics that are collected by the SDK.
- *
- * TODO: We could move this to a separate file and make it a utility class that can be used in other tests.
- * TODO: We may want to rethink how we access metrics (see `getMetricValue` method) to make it more flexible.
- */
-class TestMetricReader extends MetricReader {
-  private _exporter = new InMemoryMetricExporter(
-    AggregationTemporality.CUMULATIVE,
-  );
-
-  protected onShutdown(): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-  protected onForceFlush(): Promise<void> {
-    throw new Error("Method not implemented.");
-  }
-
-  async getMetricValue(
-    name: string,
-    attributes: { [key: string]: string | number } = {},
-  ) {
-    await this.collectAndExport();
-    const metric = this._exporter
-      .getMetrics()[0]
-      ?.scopeMetrics[0]?.metrics.find((m) => m.descriptor.name === name);
-
-    const dp = metric?.dataPoints.find(
-      (dp) => JSON.stringify(dp.attributes) === JSON.stringify(attributes),
-    );
-
-    this._exporter.reset();
-
-    return dp?.value;
-  }
-
-  async collectAndExport(): Promise<void> {
-    const result = await this.collect();
-    await new Promise<void>((resolve, reject) => {
-      this._exporter.export(result.resourceMetrics, (result) => {
-        if (result.error != null) {
-          reject(result.error);
-        } else {
-          resolve();
-        }
-      });
-    });
-  }
-}
+import {
+  createTestMetricReader,
+  tearDownTestMetricReader,
+} from "./testUtils.js";
 
 function setup() {
-  const metricReader = new TestMetricReader();
-  metrics.setGlobalMeterProvider(
-    new MeterProvider({
-      readers: [metricReader],
-    }),
-  );
-
+  const metricReader = createTestMetricReader();
   const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
   return { queue, metricReader };
 }
 
 describe("PriorityBasedMessageQueue", () => {
   afterEach(() => {
-    metrics.disable();
+    tearDownTestMetricReader();
   });
 
   test("should initialize with correct properties", () => {

package/src/tests/{SyncStateSubscriptionManager.test.ts → SyncStateManager.test.ts}

@@ -2,12 +2,19 @@ import { describe, expect, onTestFinished, test, vi } from "vitest";
 import {
   GlobalSyncStateListenerCallback,
   PeerSyncStateListenerCallback,
-} from "../SyncStateSubscriptionManager.js";
+} from "../SyncStateManager.js";
+import { accountHeaderForInitialAgentSecret } from "../coValues/account.js";
 import { connectedPeers } from "../streamUtils.js";
 import { emptyKnownState } from "../sync.js";
-import { createTestNode, waitFor } from "./testUtils.js";
-
-describe("SyncStateSubscriptionManager", () => {
+import {
+  blockMessageTypeOnOutgoingPeer,
+  createTestNode,
+  createTwoConnectedNodes,
+  loadCoValueOrFail,
+  waitFor,
+} from "./testUtils.js";
+
+describe("SyncStateManager", () => {
   test("subscribeToUpdates receives updates when peer state changes", async () => {
     // Setup nodes
     const client = createTestNode();
@@ -31,7 +38,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(jazzCloudAsPeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     const updateSpy: GlobalSyncStateListenerCallback = vi.fn();
     const unsubscribe = subscriptionManager.subscribeToUpdates(updateSpy);
@@ -41,14 +48,14 @@ describe("SyncStateSubscriptionManager", () => {
     expect(updateSpy).toHaveBeenCalledWith(
       "jazzCloudConnection",
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(updateSpy).toHaveBeenCalledWith(
@@ -56,7 +63,7 @@ describe("SyncStateSubscriptionManager", () => {
       client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
         map.core.id,
       )!,
-      { isUploaded: true },
+      { uploaded: true },
     );
 
     // Cleanup
@@ -92,7 +99,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(clientStoragePeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     const updateToJazzCloudSpy: PeerSyncStateListenerCallback = vi.fn();
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
@@ -114,26 +121,26 @@ describe("SyncStateSubscriptionManager", () => {
 
     expect(updateToJazzCloudSpy).toHaveBeenCalledWith(
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
       client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
         map.core.id,
       )!,
-      { isUploaded: true },
+      { uploaded: true },
     );
 
     expect(updateToStorageSpy).toHaveBeenLastCalledWith(
       emptyKnownState(map.core.id),
-      { isUploaded: false },
+      { uploaded: false },
     );
   });
 
@@ -162,27 +169,27 @@ describe("SyncStateSubscriptionManager", () => {
 
     await client.syncManager.actuallySyncCoValue(map.core);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
 
     expect(
-      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      ),
+      ).uploaded,
     ).toBe(false);
 
     await waitFor(() => {
-      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(
-      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      ),
+      ).uploaded,
     ).toBe(true);
   });
 
@@ -209,7 +216,7 @@ describe("SyncStateSubscriptionManager", () => {
     client.syncManager.addPeer(jazzCloudAsPeer);
     jazzCloud.syncManager.addPeer(clientAsPeer);
 
-    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const subscriptionManager = client.syncManager.syncState;
     const anyUpdateSpy = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
@@ -225,12 +232,89 @@ describe("SyncStateSubscriptionManager", () => {
     anyUpdateSpy.mockClear();
 
     await waitFor(() => {
-      return client.syncManager.syncStateSubscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+      return subscriptionManager.getCurrentSyncState(
         "jazzCloudConnection",
         map.core.id,
-      );
+      ).uploaded;
     });
 
     expect(anyUpdateSpy).not.toHaveBeenCalled();
   });
+
+  test("getCurrentSyncState should return the correct state", async () => {
+    // Setup nodes
+    const {
+      node1: clientNode,
+      node2: serverNode,
+      node1ToNode2Peer: clientToServerPeer,
+      node2ToNode1Peer: serverToClientPeer,
+    } = await createTwoConnectedNodes("client", "server");
+
+    // Create test data
+    const group = clientNode.node.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+    group.addMember("everyone", "writer");
+
+    // Initially should not be synced
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: false });
+
+    // Wait for full sync
+    await map.core.waitForSync();
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    const mapOnServer = await loadCoValueOrFail(serverNode.node, map.id);
+
+    // Block the content messages so the client won't fully sync immediately
+    const outgoing = blockMessageTypeOnOutgoingPeer(
+      serverToClientPeer,
+      "content",
+    );
+
+    mapOnServer.set("key2", "value2", "trusting");
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    expect(
+      serverNode.node.syncManager.syncState.getCurrentSyncState(
+        serverToClientPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: false });
+
+    await outgoing.sendBlockedMessages();
+    outgoing.unblock();
+
+    await mapOnServer.core.waitForSync();
+
+    expect(
+      clientNode.node.syncManager.syncState.getCurrentSyncState(
+        clientToServerPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+
+    expect(
+      serverNode.node.syncManager.syncState.getCurrentSyncState(
+        serverToClientPeer.id,
+        map.core.id,
+      ),
+    ).toEqual({ uploaded: true });
+  });
 });

package/src/tests/group.test.ts

@@ -87,12 +87,12 @@ test("Remove a member from a group where the admin role is inherited", async ()
   // The reader should be automatically kicked out of the child group
   await group.removeMember(node3.account);
 
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   // Update the map to check that node3 can't read updates anymore
   map.set("test", "Hidden to node3");
 
-  await node2.syncManager.waitForUploadIntoPeer(node2ToNode3Peer.id, map.id);
+  await map.core.waitForSync();
 
   // Check that the value has not been updated on node3
   expect(mapOnNode3.get("test")).toEqual("Available to everyone");
@@ -119,16 +119,13 @@ test("An admin should be able to rotate the readKey on child groups and keep acc
   const childGroup = node2.createGroup();
   childGroup.extend(groupOnNode2);
 
-  await node2.syncManager.waitForUploadIntoPeer(
-    node2ToNode1Peer.id,
-    childGroup.id,
-  );
+  await childGroup.core.waitForSync();
 
   // 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.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");
@@ -158,7 +155,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // 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.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");
@@ -193,7 +190,7 @@ test("An admin should be able to rotate the readKey on child groups even if it w
   // 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.account);
-  await node1.syncManager.waitForUploadIntoPeer(node1ToNode2Peer.id, group.id);
+  await group.core.waitForSync();
 
   const map = childGroup.createMap();
   map.set("test", "Available to node1");