cojson 0.13.15 → 0.13.17

package/src/tests/coValueState.test.ts

@@ -10,26 +10,15 @@ import {
 } from "vitest";
 import { PeerState } from "../PeerState";
 import { CoValueCore } from "../coValueCore";
-import { CO_VALUE_LOADING_CONFIG, CoValueState } from "../coValueState";
+import { CoValueState } from "../coValueState";
 import { RawCoID } from "../ids";
 import { Peer } from "../sync";
 import { createTestMetricReader, tearDownTestMetricReader } from "./testUtils";
 
-const initialMaxRetries = CO_VALUE_LOADING_CONFIG.MAX_RETRIES;
-
-function mockMaxRetries(maxRetries: number) {
-  CO_VALUE_LOADING_CONFIG.MAX_RETRIES = maxRetries;
-
-  onTestFinished(() => {
-    CO_VALUE_LOADING_CONFIG.MAX_RETRIES = initialMaxRetries;
-  });
-}
-
 let metricReader: ReturnType<typeof createTestMetricReader>;
 
 beforeEach(() => {
   metricReader = createTestMetricReader();
-  mockMaxRetries(5);
 });
 
 afterEach(() => {
@@ -122,51 +111,6 @@ describe("CoValueState", () => {
     ).toBe(0);
   });
 
-  test("should retry loading from peers when unsuccessful", async () => {
-    vi.useFakeTimers();
-
-    const peer1 = createMockPeerState(
-      {
-        id: "peer1",
-        role: "server",
-      },
-      async () => {
-        state.markNotFoundInPeer("peer1");
-      },
-    );
-    const peer2 = createMockPeerState(
-      {
-        id: "peer2",
-        role: "server",
-      },
-      async () => {
-        state.markNotFoundInPeer("peer2");
-      },
-    );
-    const mockPeers = [peer1, peer2] as unknown as PeerState[];
-
-    const state = new CoValueState(mockCoValueId);
-    const loadPromise = state.loadFromPeers(mockPeers);
-
-    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
-
-    await loadPromise;
-
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
-    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
-    expect(state.highLevelState).toBe("unavailable");
-    await expect(state.getCoValue()).resolves.toBe("unavailable");
-
-    vi.useRealTimers();
-  });
-
   test("should skip errored coValues when loading from peers", async () => {
     vi.useFakeTimers();
 
@@ -194,108 +138,18 @@ describe("CoValueState", () => {
     const state = new CoValueState(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
+    await vi.runAllTimersAsync();
 
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
-    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
+    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(state.highLevelState).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toBe("unavailable");
 
     vi.useRealTimers();
   });
 
-  test("should retry only on server peers", async () => {
-    vi.useFakeTimers();
-
-    const peer1 = createMockPeerState(
-      {
-        id: "peer1",
-        role: "storage",
-      },
-      async () => {
-        state.markNotFoundInPeer("peer1");
-      },
-    );
-    const peer2 = createMockPeerState(
-      {
-        id: "peer2",
-        role: "server",
-      },
-      async () => {
-        state.markNotFoundInPeer("peer2");
-      },
-    );
-    const mockPeers = [peer1, peer2] as unknown as PeerState[];
-
-    const state = new CoValueState(mockCoValueId);
-    const loadPromise = state.loadFromPeers(mockPeers);
-
-    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
-
-    await loadPromise;
-
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
-    expect(peer2.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
-    expect(state.highLevelState).toBe("unavailable");
-    await expect(state.getCoValue()).resolves.toEqual("unavailable");
-
-    vi.useRealTimers();
-  });
-
-  test("should handle the coValues that become available in between of the retries", async () => {
-    vi.useFakeTimers();
-
-    mockMaxRetries(5);
-
-    let retries = 0;
-
-    const peer1 = createMockPeerState(
-      {
-        id: "peer1",
-        role: "server",
-      },
-      async () => {
-        retries++;
-        state.markNotFoundInPeer("peer1");
-
-        if (retries === 2) {
-          setTimeout(() => {
-            state.markAvailable(createMockCoValueCore(mockCoValueId), "peer1");
-          }, 100);
-        }
-      },
-    );
-
-    const mockPeers = [peer1] as unknown as PeerState[];
-
-    const state = new CoValueState(mockCoValueId);
-    const loadPromise = state.loadFromPeers(mockPeers);
-
-    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES + 1; i++) {
-      await vi.runAllTimersAsync();
-    }
-
-    await loadPromise;
-
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(2);
-    expect(state.highLevelState).toBe("available");
-    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
-    vi.useRealTimers();
-  });
-
   test("should have a coValue as value property when becomes available after that have been marked as unavailable", async () => {
     vi.useFakeTimers();
 
@@ -314,57 +168,13 @@ describe("CoValueState", () => {
     const state = new CoValueState(mockCoValueId);
     const loadPromise = state.loadFromPeers(mockPeers);
 
-    // Should attempt CO_VALUE_LOADING_CONFIG.MAX_RETRIES retries
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
+    await vi.runAllTimersAsync();
 
     state.internalMarkMagicallyAvailable(createMockCoValueCore(mockCoValueId));
 
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
-    expect(state.highLevelState).toBe("available");
-    await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
-
-    vi.useRealTimers();
-  });
-
-  test("should stop retrying when value becomes available", async () => {
-    vi.useFakeTimers();
-
-    mockMaxRetries(5);
-
-    let run = 1;
-
-    const peer1 = createMockPeerState(
-      {
-        id: "peer1",
-        role: "server",
-      },
-      async () => {
-        if (run > 2) {
-          state.markAvailable(createMockCoValueCore(mockCoValueId), "peer1");
-        } else {
-          state.markNotFoundInPeer("peer1");
-          run++;
-        }
-      },
-    );
-
-    const mockPeers = [peer1] as unknown as PeerState[];
-
-    const state = new CoValueState(mockCoValueId);
-    const loadPromise = state.loadFromPeers(mockPeers);
-
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
-    await loadPromise;
-
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(3);
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
     expect(state.highLevelState).toBe("available");
     await expect(state.getCoValue()).resolves.toEqual({ id: mockCoValueId });
 
@@ -398,9 +208,7 @@ describe("CoValueState", () => {
     const state = new CoValueState(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
+    await vi.runAllTimersAsync();
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
@@ -444,9 +252,7 @@ describe("CoValueState", () => {
     const state = new CoValueState(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1, peer2]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES; i++) {
-      await vi.runAllTimersAsync();
-    }
+    await vi.runAllTimersAsync();
     await loadPromise;
 
     expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(0);
@@ -472,14 +278,10 @@ describe("CoValueState", () => {
     const state = new CoValueState(mockCoValueId);
     const loadPromise = state.loadFromPeers([peer1]);
 
-    for (let i = 0; i < CO_VALUE_LOADING_CONFIG.MAX_RETRIES * 2; i++) {
-      await vi.runAllTimersAsync();
-    }
+    await vi.runAllTimersAsync();
     await loadPromise;
 
-    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(
-      CO_VALUE_LOADING_CONFIG.MAX_RETRIES,
-    );
+    expect(peer1.pushOutgoingMessage).toHaveBeenCalledTimes(1);
 
     expect(state.highLevelState).toBe("unavailable");
     await expect(state.getCoValue()).resolves.toEqual("unavailable");

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

@@ -45,6 +45,53 @@ describe("loading coValues from server", () => {
     `);
   });
 
+  test("unavailable coValue retry", async () => {
+    const client = setupTestNode();
+    const client2 = setupTestNode();
+
+    client2.connectToSyncServer({
+      ourName: "client2",
+    });
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    const promise = loadCoValueOrFail(client2.node, map.id);
+
+    await new Promise((resolve) => setTimeout(resolve, 1));
+
+    client.connectToSyncServer();
+
+    const mapOnClient2 = await promise;
+
+    expect(mapOnClient2.get("hello")).toEqual("world");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client2 -> server | LOAD Map sessions: empty",
+        "server -> client2 | KNOWN Map sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "client -> server | LOAD Map sessions: header/1",
+        "server -> client | KNOWN Group sessions: empty",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Map sessions: empty",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> client | KNOWN Map sessions: header/1",
+        "server -> client2 | CONTENT Group header: true new: After: 0 New: 3",
+        "client2 -> server | KNOWN Group sessions: header/3",
+        "server -> client2 | CONTENT Map header: true new: After: 0 New: 1",
+        "client2 -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
   test("coValue with parent groups loading", async () => {
     const client = setupTestNode({
       connected: true,
@@ -327,5 +374,35 @@ describe("loading coValues from server", () => {
     `);
   });
 
-  test.todo("should mark the coValue as unavailable if the peer is closed");
+  test("should mark the coValue as unavailable if the peer is closed", async () => {
+    const client = setupTestNode();
+    const { peerState } = client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    group.addMember("everyone", "writer");
+
+    const map = group.createMap({
+      test: "value",
+    });
+
+    const promise = client.node.load(map.id);
+
+    // Close the peer connection
+    peerState.gracefulShutdown();
+
+    expect(await promise).toEqual("unavailable");
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 5",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+  });
 });

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

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, test, vi } from "vitest";
 import { expectMap } from "../coValue";
 import {
   SyncMessagesLog,
+  blockMessageTypeOnOutgoingPeer,
   loadCoValueOrFail,
   setupTestNode,
   waitFor,
@@ -322,4 +323,70 @@ describe("multiple clients syncing with the a cloud-like server mesh", () => {
       ]
     `);
   });
+
+  test("load returns the coValue as soon as one of the peers return the content", async () => {
+    const client = setupTestNode();
+    const coreServer = setupTestNode({
+      isSyncServer: true,
+    });
+
+    const { peerOnServer } = client.connectToSyncServer({
+      syncServerName: "core",
+    });
+
+    const storage = setupTestNode();
+
+    const { peer: storagePeer } = client.connectToSyncServer({
+      syncServerName: "storage",
+      syncServer: storage.node,
+    });
+
+    storagePeer.priority = 100;
+
+    const group = coreServer.node.createGroup();
+    const map = group.createMap();
+
+    map.set("hello", "world", "trusting");
+
+    const { peerState } = storage.connectToSyncServer({
+      ourName: "storage-of-client",
+      syncServerName: "core",
+    });
+
+    await loadCoValueOrFail(storage.node, map.id);
+
+    peerState.gracefulShutdown();
+
+    SyncMessagesLog.clear();
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    map.set("hello", "updated", "trusting");
+
+    // Block the content message from the core peer to simulate the delay on response
+    blockMessageTypeOnOutgoingPeer(peerOnServer, "content");
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> storage | LOAD Map sessions: empty",
+        "storage -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | KNOWN Group sessions: header/3",
+        "storage -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> core | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | KNOWN Map sessions: header/1",
+        "core -> client | KNOWN Group sessions: header/3",
+        "client -> core | LOAD Map sessions: header/1",
+        "client -> core | CONTENT Map header: true new: After: 0 New: 1",
+      ]
+    `);
+
+    expect(mapOnClient.get("hello")).toEqual("world");
+  });
 });