cojson 0.19.20 → 0.19.22

package/src/tests/knownState.lazyLoading.test.ts

@@ -0,0 +1,219 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { RawCoID, SessionID } from "../ids";
+import { PeerID } from "../sync";
+import { StorageAPI } from "../storage/types";
+import { CoValueKnownState, peerHasAllContent } from "../knownState";
+import { createTestNode, createUnloadedCoValue } from "./testUtils";
+
+function createMockStorage(
+  opts: {
+    load?: (
+      id: RawCoID,
+      callback: (data: any) => void,
+      done: (found: boolean) => void,
+    ) => void;
+    store?: (data: any, correctionCallback: any) => void;
+    getKnownState?: (id: RawCoID) => any;
+    loadKnownState?: (id: string, callback: (knownState: any) => void) => void;
+    waitForSync?: (id: string, coValue: any) => Promise<void>;
+    trackCoValuesSyncState?: (
+      operations: Array<{ id: RawCoID; peerId: PeerID; synced: boolean }>,
+    ) => void;
+    getUnsyncedCoValueIDs?: (
+      callback: (unsyncedCoValueIDs: RawCoID[]) => void,
+    ) => void;
+    stopTrackingSyncState?: (id: RawCoID) => void;
+    onCoValueUnmounted?: (id: RawCoID) => void;
+    close?: () => Promise<unknown> | undefined;
+  } = {},
+): StorageAPI {
+  return {
+    load: opts.load || vi.fn(),
+    store: opts.store || vi.fn(),
+    getKnownState: opts.getKnownState || vi.fn(),
+    loadKnownState:
+      opts.loadKnownState || vi.fn((id, callback) => callback(undefined)),
+    waitForSync: opts.waitForSync || vi.fn().mockResolvedValue(undefined),
+    trackCoValuesSyncState: opts.trackCoValuesSyncState || vi.fn(),
+    getUnsyncedCoValueIDs: opts.getUnsyncedCoValueIDs || vi.fn(),
+    stopTrackingSyncState: opts.stopTrackingSyncState || vi.fn(),
+    onCoValueUnmounted: opts.onCoValueUnmounted || vi.fn(),
+    close: opts.close || vi.fn().mockResolvedValue(undefined),
+  };
+}
+
+describe("peerHasAllContent", () => {
+  const storageKnownState: CoValueKnownState = {
+    id: "co_test123" as RawCoID,
+    header: true,
+    sessions: {
+      ["session1" as SessionID]: 5,
+      ["session2" as SessionID]: 3,
+    },
+  };
+
+  test("returns false when peerKnownState is undefined", () => {
+    expect(peerHasAllContent(storageKnownState, undefined)).toBe(false);
+  });
+
+  test("returns false when peer does not have header but storage does", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: false,
+      sessions: {
+        ["session1" as SessionID]: 5,
+        ["session2" as SessionID]: 3,
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(false);
+  });
+
+  test("returns false when peer has fewer transactions in a session", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {
+        ["session1" as SessionID]: 3, // Less than storage's 5
+        ["session2" as SessionID]: 3,
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(false);
+  });
+
+  test("returns false when peer is missing a session", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {
+        ["session1" as SessionID]: 5,
+        // session2 is missing
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(false);
+  });
+
+  test("returns true when peer has exactly the same content", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {
+        ["session1" as SessionID]: 5,
+        ["session2" as SessionID]: 3,
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(true);
+  });
+
+  test("returns true when peer has more transactions than storage", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {
+        ["session1" as SessionID]: 10, // More than storage's 5
+        ["session2" as SessionID]: 5, // More than storage's 3
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(true);
+  });
+
+  test("returns true when peer has additional sessions", () => {
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {
+        ["session1" as SessionID]: 5,
+        ["session2" as SessionID]: 3,
+        ["session3" as SessionID]: 2, // Extra session not in storage
+      },
+    };
+    expect(peerHasAllContent(storageKnownState, peerKnownState)).toBe(true);
+  });
+
+  test("returns true when storage has empty sessions", () => {
+    const emptyStorageKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {},
+    };
+    const peerKnownState: CoValueKnownState = {
+      id: "co_test123" as RawCoID,
+      header: true,
+      sessions: {},
+    };
+    expect(peerHasAllContent(emptyStorageKnownState, peerKnownState)).toBe(
+      true,
+    );
+  });
+});
+
+describe("CoValueCore.getKnownStateFromStorage", () => {
+  function setup() {
+    const node = createTestNode();
+    const { coValue, id, header } = createUnloadedCoValue(node);
+    return { node, coValue, id, header };
+  }
+
+  test("returns undefined when storage is not configured", () => {
+    const { coValue } = setup();
+    const doneSpy = vi.fn();
+
+    coValue.getKnownStateFromStorage(doneSpy);
+
+    expect(doneSpy).toHaveBeenCalledWith(undefined);
+  });
+
+  test("returns current knownState when CoValue is already available", () => {
+    const { node, coValue, header } = setup();
+    const storage = createMockStorage();
+    node.setStorage(storage);
+
+    // Make the CoValue available by providing header
+    coValue.provideHeader(header, undefined, false);
+
+    const doneSpy = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy);
+
+    expect(doneSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        header: true,
+      }),
+    );
+  });
+
+  test("calls storage.loadKnownState when CoValue not in memory", () => {
+    const { node, coValue, id } = setup();
+    const loadKnownStateSpy = vi.fn((id, callback) => {
+      callback({
+        id,
+        header: true,
+        sessions: { session1: 5 },
+      });
+    });
+    const storage = createMockStorage({ loadKnownState: loadKnownStateSpy });
+    node.setStorage(storage);
+
+    const doneSpy = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy);
+
+    expect(loadKnownStateSpy).toHaveBeenCalledWith(id, expect.any(Function));
+    expect(doneSpy).toHaveBeenCalledWith({
+      id,
+      header: true,
+      sessions: { session1: 5 },
+    });
+  });
+
+  test("returns undefined when storage does not have the CoValue", () => {
+    const { node, coValue } = setup();
+    const loadKnownStateSpy = vi.fn((id, callback) => {
+      callback(undefined);
+    });
+    const storage = createMockStorage({ loadKnownState: loadKnownStateSpy });
+    node.setStorage(storage);
+
+    const doneSpy = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy);
+
+    expect(doneSpy).toHaveBeenCalledWith(undefined);
+  });
+});

package/src/tests/messagesTestUtils.ts

@@ -1,6 +1,7 @@
 import { CoValueCore, LocalNode } from "../exports";
 import { NewContentMessage, SyncMessage } from "../sync";
 import { CoValueKnownState } from "../knownState.js";
+import { LazyLoadMessage, LazyLoadResultMessage } from "./testUtils.js";
 
 function simplifySessions(msg: Pick<CoValueKnownState, "sessions" | "header">) {
   const count = Object.values(msg.sessions).reduce(
@@ -25,12 +26,14 @@ function simplifyNewContent(content: NewContentMessage["new"]) {
     .join(" | ");
 }
 
+type TestMessage = SyncMessage | LazyLoadMessage | LazyLoadResultMessage;
+
 export function toSimplifiedMessages(
   coValues: Record<string, CoValueCore>,
   messages: {
     from: string;
     to: string;
-    msg: SyncMessage;
+    msg: TestMessage;
   }[],
 ) {
   function getCoValue(id: string) {
@@ -43,7 +46,7 @@ export function toSimplifiedMessages(
     return `unknown/${id}`;
   }
 
-  function toDebugString(from: string, to: string, msg: SyncMessage) {
+  function toDebugString(from: string, to: string, msg: TestMessage) {
     switch (msg.action) {
       case "known":
         return `${from} -> ${to} | KNOWN ${msg.isCorrection ? "CORRECTION " : ""}${getCoValue(msg.id)} sessions: ${simplifySessions(msg)}`;
@@ -53,6 +56,10 @@ export function toSimplifiedMessages(
         return `${from} -> ${to} | DONE ${getCoValue(msg.id)}`;
       case "content":
         return `${from} -> ${to} | CONTENT ${getCoValue(msg.id)} header: ${Boolean(msg.header)} new: ${simplifyNewContent(msg.new)}${msg.expectContentUntil ? ` expectContentUntil: ${simplifySessions({ sessions: msg.expectContentUntil, header: true })}` : ""}`;
+      case "lazyLoad":
+        return `${from} -> ${to} | GET_KNOWN_STATE ${getCoValue(msg.id)}`;
+      case "lazyLoadResult":
+        return `${from} -> ${to} | GET_KNOWN_STATE_RESULT ${getCoValue(msg.id)} sessions: ${simplifySessions(msg)}`;
     }
   }
 
@@ -75,7 +82,7 @@ export function debugMessages(
   messages: {
     from: string;
     to: string;
-    msg: SyncMessage;
+    msg: TestMessage;
   }[],
 ) {
   console.log(toSimplifiedMessages(coValues, messages));

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

@@ -50,6 +50,47 @@ describe("sync after the garbage collector has run", () => {
     const mapOnClient = await loadCoValueOrFail(client.node, map.id);
     expect(mapOnClient.get("hello")).toEqual("world");
 
+    expect(
+      SyncMessagesLog.getMessages({
+        Group: group.core,
+        Map: map.core,
+      }),
+    ).toMatchInlineSnapshot(`
+      [
+        "client -> server | LOAD Map sessions: empty",
+        "server -> storage | LOAD Map sessions: empty",
+        "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> client | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | KNOWN Group sessions: header/3",
+        "client -> server | KNOWN Map sessions: header/1",
+      ]
+    `);
+  });
+
+  test("loading a coValue from the sync server that was removed by the garbage collector along with its owner", async () => {
+    const client = setupTestNode();
+
+    client.connectToSyncServer();
+
+    const group = jazzCloud.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    await map.core.waitForSync();
+
+    // force the garbage collector to run twice to remove the map and its group
+    jazzCloud.node.garbageCollector?.collect();
+    jazzCloud.node.garbageCollector?.collect();
+
+    expect(jazzCloud.node.getCoValue(group.id).isAvailable()).toBe(false);
+    expect(jazzCloud.node.getCoValue(map.id).isAvailable()).toBe(false);
+
+    SyncMessagesLog.clear();
+
+    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
+    expect(mapOnClient.get("hello")).toEqual("world");
+
     expect(
       SyncMessagesLog.getMessages({
         Group: group.core,
@@ -103,7 +144,6 @@ describe("sync after the garbage collector has run", () => {
       [
         "client -> server | CONTENT Map header: false new: After: 0 New: 1",
         "server -> storage | LOAD Map sessions: empty",
-        "storage -> server | CONTENT Group header: true new: After: 0 New: 5",
         "storage -> server | CONTENT Map header: true new: After: 0 New: 1",
         "server -> client | KNOWN Map sessions: header/2",
         "server -> storage | CONTENT Map header: false new: After: 0 New: 1",
@@ -112,41 +152,30 @@ describe("sync after the garbage collector has run", () => {
   });
 
   test("syncing a coValue that was removed by the garbage collector", async () => {
-    const edge = setupTestNode();
-    edge.addStorage({
-      ourName: "edge",
-    });
-    edge.connectToSyncServer({
-      syncServer: jazzCloud.node,
-      syncServerName: "server",
-      ourName: "edge",
-    });
-    edge.node.enableGarbageCollector();
     const client = setupTestNode();
-
-    client.connectToSyncServer({
-      syncServer: edge.node,
-      syncServerName: "edge",
+    client.addStorage({
+      ourName: "client",
     });
+    client.node.enableGarbageCollector();
 
-    const group = edge.node.createGroup();
-    group.addMember("everyone", "writer");
-
-    await group.core.waitForSync();
-
+    const group = client.node.createGroup();
     const map = group.createMap();
-
     map.set("hello", "updated", "trusting");
 
     // force the garbage collector to run before the transaction is synced
-    edge.node.garbageCollector?.collect();
-    expect(edge.node.getCoValue(map.id).isAvailable()).toBe(false);
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
 
     SyncMessagesLog.clear();
 
+    client.connectToSyncServer();
+
+    // Wait for unsynced coValues to be resumed and synced after connecting to server
+    await client.node.syncManager.waitForAllCoValuesSync();
+
     // The storage should work even after the coValue is unmounted, so the load should be successful
-    const mapOnClient = await loadCoValueOrFail(client.node, map.id);
-    expect(mapOnClient.get("hello")).toEqual("updated");
+    const mapOnServer = await loadCoValueOrFail(jazzCloud.node, map.id);
+    expect(mapOnServer.get("hello")).toEqual("updated");
 
     expect(
       SyncMessagesLog.getMessages({
@@ -155,18 +184,22 @@ describe("sync after the garbage collector has run", () => {
       }),
     ).toMatchInlineSnapshot(`
       [
-        "client -> edge | LOAD Map sessions: empty",
-        "edge -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> server | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> storage | LOAD Map sessions: empty",
-        "storage -> edge | CONTENT Group header: true new: After: 0 New: 5",
-        "storage -> edge | CONTENT Map header: true new: After: 0 New: 1",
-        "edge -> client | CONTENT Group header: true new: After: 0 New: 5",
-        "edge -> client | CONTENT Map header: true new: After: 0 New: 1",
-        "server -> edge | KNOWN Map sessions: header/1",
+        "client -> server | LOAD Map sessions: empty",
+        "client -> server | LOAD Group sessions: header/3",
+        "client -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> server | CONTENT Group header: true new: After: 0 New: 3",
+        "client -> storage | CONTENT Map header: true new: After: 0 New: 1",
+        "client -> server | CONTENT Map header: true new: After: 0 New: 1",
+        "server -> storage | LOAD Map sessions: empty",
+        "storage -> server | KNOWN Map sessions: empty",
+        "server -> client | KNOWN Map sessions: empty",
+        "server -> storage | GET_KNOWN_STATE Group",
+        "storage -> server | GET_KNOWN_STATE_RESULT Group sessions: empty",
+        "server -> client | KNOWN Group sessions: empty",
+        "server -> client | KNOWN Group sessions: header/3",
+        "server -> storage | CONTENT Group header: true new: After: 0 New: 3",
+        "server -> client | KNOWN Map sessions: header/1",
         "server -> storage | CONTENT Map header: true new: After: 0 New: 1",
-        "client -> edge | KNOWN Group sessions: header/5",
-        "client -> edge | KNOWN Map sessions: header/1",
       ]
     `);
   });