cojson 0.8.12 → 0.8.17

package/src/tests/SyncStateSubscriptionManager.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, onTestFinished, test, vi } from "vitest";
+import { connectedPeers } from "../streamUtils.js";
+import { emptyKnownState } from "../sync.js";
+import { createTestNode, waitFor } from "./testUtils.js";
+
+describe("SyncStateSubscriptionManager", () => {
+  test("subscribeToUpdates receives updates when peer state changes", async () => {
+    // Setup nodes
+    const client = createTestNode();
+    const jazzCloud = createTestNode();
+
+    // Create test data
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Connect nodes
+    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
+      "clientConnection",
+      "jazzCloudConnection",
+      {
+        peer1role: "client",
+        peer2role: "server",
+      },
+    );
+
+    client.syncManager.addPeer(jazzCloudAsPeer);
+    jazzCloud.syncManager.addPeer(clientAsPeer);
+
+    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+
+    const updateSpy = vi.fn();
+    const unsubscribe = subscriptionManager.subscribeToUpdates(updateSpy);
+
+    await client.syncManager.actuallySyncCoValue(map.core);
+
+    expect(updateSpy).toHaveBeenCalledWith(
+      "jazzCloudConnection",
+      emptyKnownState(map.core.id),
+      false,
+    );
+
+    await waitFor(() => {
+      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      );
+    });
+
+    expect(updateSpy).toHaveBeenCalledWith(
+      "jazzCloudConnection",
+      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+        map.core.id,
+      )!,
+      true,
+    );
+
+    // Cleanup
+    unsubscribe();
+  });
+
+  test("subscribeToPeerUpdates receives updates only for specific peer", async () => {
+    // Setup nodes
+    const client = createTestNode();
+    const jazzCloud = createTestNode();
+
+    // Create test data
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Connect nodes
+    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
+      "clientConnection",
+      "jazzCloudConnection",
+      {
+        peer1role: "client",
+        peer2role: "server",
+      },
+    );
+
+    const [clientStoragePeer] = connectedPeers("clientStorage", "unusedPeer", {
+      peer1role: "client",
+      peer2role: "server",
+    });
+
+    client.syncManager.addPeer(jazzCloudAsPeer);
+    client.syncManager.addPeer(clientStoragePeer);
+    jazzCloud.syncManager.addPeer(clientAsPeer);
+
+    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+
+    const updateToJazzCloudSpy = vi.fn();
+    const updateToStorageSpy = vi.fn();
+    const unsubscribe1 = subscriptionManager.subscribeToPeerUpdates(
+      "jazzCloudConnection",
+      updateToJazzCloudSpy,
+    );
+    const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
+      "clientStorage",
+      updateToStorageSpy,
+    );
+
+    onTestFinished(() => {
+      unsubscribe1();
+      unsubscribe2();
+    });
+
+    await client.syncManager.actuallySyncCoValue(map.core);
+
+    expect(updateToJazzCloudSpy).toHaveBeenCalledWith(
+      emptyKnownState(map.core.id),
+      false,
+    );
+
+    await waitFor(() => {
+      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      );
+    });
+
+    expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
+      client.syncManager.peers["jazzCloudConnection"]!.knownStates.get(
+        map.core.id,
+      )!,
+      true,
+    );
+
+    expect(updateToStorageSpy).toHaveBeenLastCalledWith(
+      emptyKnownState(map.core.id),
+      false,
+    );
+  });
+
+  test("getIsCoValueFullyUploadedIntoPeer returns correct status", async () => {
+    // Setup nodes
+    const client = createTestNode();
+    const jazzCloud = createTestNode();
+
+    // Create test data
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Connect nodes
+    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
+      "clientConnection",
+      "jazzCloudConnection",
+      {
+        peer1role: "client",
+        peer2role: "server",
+      },
+    );
+
+    client.syncManager.addPeer(jazzCloudAsPeer);
+    jazzCloud.syncManager.addPeer(clientAsPeer);
+
+    await client.syncManager.actuallySyncCoValue(map.core);
+
+    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+
+    expect(
+      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      ),
+    ).toBe(false);
+
+    await waitFor(() => {
+      return subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      );
+    });
+
+    expect(
+      subscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      ),
+    ).toBe(true);
+  });
+
+  test("unsubscribe stops receiving updates", async () => {
+    // Setup nodes
+    const client = createTestNode();
+    const jazzCloud = createTestNode();
+
+    // Create test data
+    const group = client.createGroup();
+    const map = group.createMap();
+    map.set("key1", "value1", "trusting");
+
+    // Connect nodes
+    const [clientAsPeer, jazzCloudAsPeer] = connectedPeers(
+      "clientConnection",
+      "jazzCloudConnection",
+      {
+        peer1role: "client",
+        peer2role: "server",
+      },
+    );
+
+    client.syncManager.addPeer(jazzCloudAsPeer);
+    jazzCloud.syncManager.addPeer(clientAsPeer);
+
+    const subscriptionManager = client.syncManager.syncStateSubscriptionManager;
+    const anyUpdateSpy = vi.fn();
+    const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
+    const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
+      "jazzCloudConnection",
+      anyUpdateSpy,
+    );
+
+    unsubscribe1();
+    unsubscribe2();
+
+    await client.syncManager.actuallySyncCoValue(map.core);
+
+    anyUpdateSpy.mockClear();
+
+    await waitFor(() => {
+      return client.syncManager.syncStateSubscriptionManager.getIsCoValueFullyUploadedIntoPeer(
+        "jazzCloudConnection",
+        map.core.id,
+      );
+    });
+
+    expect(anyUpdateSpy).not.toHaveBeenCalled();
+  });
+});

package/src/tests/account.test.ts

@@ -1,76 +1,76 @@
 import { expect, test } from "vitest";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { connectedPeers } from "../streamUtils.js";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Can create a node while creating a new account with profile", async () => {
-    const { node, accountID, accountSecret, sessionID } =
-        await LocalNode.withNewlyCreatedAccount({
-            creationProps: { name: "Hermes Puggington" },
-            crypto: Crypto,
-        });
-
-    expect(node).not.toBeNull();
-    expect(accountID).not.toBeNull();
-    expect(accountSecret).not.toBeNull();
-    expect(sessionID).not.toBeNull();
-
-    expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
-        "Hermes Puggington",
-    );
-});
-
-test("A node with an account can create groups and and objects within them", async () => {
-    const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
-        creationProps: { name: "Hermes Puggington" },
-        crypto: Crypto,
+  const { node, accountID, accountSecret, sessionID } =
+    await LocalNode.withNewlyCreatedAccount({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
     });
 
-    const group = await node.createGroup();
-    expect(group).not.toBeNull();
+  expect(node).not.toBeNull();
+  expect(accountID).not.toBeNull();
+  expect(accountSecret).not.toBeNull();
+  expect(sessionID).not.toBeNull();
+
+  expect(node.expectProfileLoaded(accountID).get("name")).toEqual(
+    "Hermes Puggington",
+  );
+});
 
-    const map = group.createMap();
-    map.set("foo", "bar", "private");
-    expect(map.get("foo")).toEqual("bar");
-    expect(map.lastEditAt("foo")?.by).toEqual(accountID);
+test("A node with an account can create groups and and objects within them", async () => {
+  const { node, accountID } = await LocalNode.withNewlyCreatedAccount({
+    creationProps: { name: "Hermes Puggington" },
+    crypto: Crypto,
+  });
+
+  const group = await node.createGroup();
+  expect(group).not.toBeNull();
+
+  const map = group.createMap();
+  map.set("foo", "bar", "private");
+  expect(map.get("foo")).toEqual("bar");
+  expect(map.lastEditAt("foo")?.by).toEqual(accountID);
 });
 
 test("Can create account with one node, and then load it on another", async () => {
-    const { node, accountID, accountSecret } =
-        await LocalNode.withNewlyCreatedAccount({
-            creationProps: { name: "Hermes Puggington" },
-            crypto: Crypto,
-        });
-
-    const group = await node.createGroup();
-    expect(group).not.toBeNull();
-
-    const map = group.createMap();
-    map.set("foo", "bar", "private");
-    expect(map.get("foo")).toEqual("bar");
-
-    const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
-        trace: true,
-        peer1role: "server",
-        peer2role: "client",
-    })
-
-    console.log("After connected peers");
-
-    node.syncManager.addPeer(node2asPeer);
-
-    const node2 = await LocalNode.withLoadedAccount({
-        accountID,
-        accountSecret,
-        sessionID: Crypto.newRandomSessionID(accountID),
-        peersToLoadFrom: [node1asPeer],
-        crypto: Crypto,
+  const { node, accountID, accountSecret } =
+    await LocalNode.withNewlyCreatedAccount({
+      creationProps: { name: "Hermes Puggington" },
+      crypto: Crypto,
     });
 
-    const map2 = await node2.load(map.id);
-    if (map2 === "unavailable") throw new Error("Map unavailable");
+  const group = await node.createGroup();
+  expect(group).not.toBeNull();
+
+  const map = group.createMap();
+  map.set("foo", "bar", "private");
+  expect(map.get("foo")).toEqual("bar");
+
+  const [node1asPeer, node2asPeer] = connectedPeers("node1", "node2", {
+    trace: true,
+    peer1role: "server",
+    peer2role: "client",
+  });
+
+  console.log("After connected peers");
+
+  node.syncManager.addPeer(node2asPeer);
+
+  const node2 = await LocalNode.withLoadedAccount({
+    accountID,
+    accountSecret,
+    sessionID: Crypto.newRandomSessionID(accountID),
+    peersToLoadFrom: [node1asPeer],
+    crypto: Crypto,
+  });
+
+  const map2 = await node2.load(map.id);
+  if (map2 === "unavailable") throw new Error("Map unavailable");
 
-    expect(map2.get("foo")).toEqual("bar");
+  expect(map2.get("foo")).toEqual("bar");
 });

package/src/tests/coList.test.ts

@@ -1,94 +1,94 @@
 import { expect, test } from "vitest";
 import { expectList } from "../coValue.js";
+import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-import { WasmCrypto } from "../crypto/WasmCrypto.js";
 
 const Crypto = await WasmCrypto.create();
 
 test("Empty CoList works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
-    expect(content.toJSON()).toEqual([]);
+  expect(content.type).toEqual("colist");
+  expect(content.toJSON()).toEqual([]);
 });
 
 test("Can append, prepend, delete and replace items in CoList", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
-
-    const content = expectList(coValue.getCurrentContent());
-
-    content.append("hello", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
-    content.append("world", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world"]);
-    content.prepend("beautiful", 1, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "world"]);
-    content.prepend("hooray", 3, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
-    content.replace(2, "universe", "trusting");
-    expect(content.toJSON()).toEqual([
-        "hello",
-        "beautiful",
-        "universe",
-        "hooray",
-    ]);
-    content.delete(2, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const content = expectList(coValue.getCurrentContent());
+
+  content.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.append("world", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world"]);
+  content.prepend("beautiful", 1, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "world"]);
+  content.prepend("hooray", 3, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "world", "hooray"]);
+  content.replace(2, "universe", "trusting");
+  expect(content.toJSON()).toEqual([
+    "hello",
+    "beautiful",
+    "universe",
+    "hooray",
+  ]);
+  content.delete(2, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
 });
 
 test("Push is equivalent to append after last item", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
+  expect(content.type).toEqual("colist");
 
-    content.append("hello", 0, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
-    content.append("world", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world"]);
-    content.append("hooray", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
+  content.append("hello", 0, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
+  content.append("world", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world"]);
+  content.append("hooray", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello", "world", "hooray"]);
 });
 
 test("Can push into empty list", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...Crypto.createdNowUnique(),
-    });
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
 
-    const content = expectList(coValue.getCurrentContent());
+  const content = expectList(coValue.getCurrentContent());
 
-    expect(content.type).toEqual("colist");
+  expect(content.type).toEqual("colist");
 
-    content.append("hello", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
+  content.append("hello", undefined, "trusting");
+  expect(content.toJSON()).toEqual(["hello"]);
 });