cojson 0.13.5 → 0.13.10

package/src/tests/SyncStateManager.test.ts

@@ -6,54 +6,53 @@ import {
 import { connectedPeers } from "../streamUtils.js";
 import { emptyKnownState } from "../sync.js";
 import {
+  SyncMessagesLog,
   blockMessageTypeOnOutgoingPeer,
-  connectNodeToSyncServer,
   createTestNode,
   loadCoValueOrFail,
-  setupSyncServer,
+  setupTestNode,
   waitFor,
 } from "./testUtils.js";
 
-let jazzCloud = setupSyncServer();
+let jazzCloud = setupTestNode({ isSyncServer: true });
 
 beforeEach(async () => {
-  jazzCloud = setupSyncServer();
+  SyncMessagesLog.clear();
+  jazzCloud = setupTestNode({ isSyncServer: true });
 });
 
 describe("SyncStateManager", () => {
   test("subscribeToUpdates receives updates when peer state changes", async () => {
     // Setup nodes
-    const client = createTestNode();
-    const { nodeToServerPeer } = connectNodeToSyncServer(client);
+    const client = setupTestNode({ connected: true });
+    const { peerState } = client.connectToSyncServer();
 
     // Create test data
-    const group = client.createGroup();
+    const group = client.node.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    const subscriptionManager = client.syncManager.syncState;
+    const subscriptionManager = client.node.syncManager.syncState;
 
     const updateSpy: GlobalSyncStateListenerCallback = vi.fn();
     const unsubscribe = subscriptionManager.subscribeToUpdates(updateSpy);
 
-    await client.syncManager.actuallySyncCoValue(map.core);
+    await client.node.syncManager.actuallySyncCoValue(map.core);
 
     expect(updateSpy).toHaveBeenCalledWith(
-      nodeToServerPeer.id,
+      peerState.id,
       emptyKnownState(map.core.id),
       { uploaded: false },
     );
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(
-        nodeToServerPeer.id,
-        map.core.id,
-      ).uploaded;
+      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
+        .uploaded;
     });
 
     expect(updateSpy).toHaveBeenCalledWith(
-      nodeToServerPeer.id,
-      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
+      peerState.id,
+      client.node.syncManager.peers[peerState.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -65,11 +64,11 @@ describe("SyncStateManager", () => {
 
   test("subscribeToPeerUpdates receives updates only for specific peer", async () => {
     // Setup nodes
-    const client = createTestNode();
-    const { nodeToServerPeer } = connectNodeToSyncServer(client);
+    const client = setupTestNode({ connected: true });
+    const { peerState } = client.connectToSyncServer();
 
     // Create test data
-    const group = client.createGroup();
+    const group = client.node.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
@@ -78,14 +77,14 @@ describe("SyncStateManager", () => {
       peer2role: "server",
     });
 
-    client.syncManager.addPeer(clientStoragePeer);
+    client.node.syncManager.addPeer(clientStoragePeer);
 
-    const subscriptionManager = client.syncManager.syncState;
+    const subscriptionManager = client.node.syncManager.syncState;
 
     const updateToJazzCloudSpy: PeerSyncStateListenerCallback = vi.fn();
     const updateToStorageSpy: PeerSyncStateListenerCallback = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToPeerUpdates(
-      nodeToServerPeer.id,
+      peerState.id,
       updateToJazzCloudSpy,
     );
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
@@ -98,7 +97,7 @@ describe("SyncStateManager", () => {
       unsubscribe2();
     });
 
-    await client.syncManager.actuallySyncCoValue(map.core);
+    await client.node.syncManager.actuallySyncCoValue(map.core);
 
     expect(updateToJazzCloudSpy).toHaveBeenCalledWith(
       emptyKnownState(map.core.id),
@@ -106,14 +105,12 @@ describe("SyncStateManager", () => {
     );
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(
-        nodeToServerPeer.id,
-        map.core.id,
-      ).uploaded;
+      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
+        .uploaded;
     });
 
     expect(updateToJazzCloudSpy).toHaveBeenLastCalledWith(
-      client.syncManager.peers[nodeToServerPeer.id]!.knownStates.get(
+      client.node.syncManager.peers[peerState.id]!.knownStates.get(
         map.core.id,
       )!,
       { uploaded: true },
@@ -127,66 +124,62 @@ describe("SyncStateManager", () => {
 
   test("getIsCoValueFullyUploadedIntoPeer returns correct status", async () => {
     // Setup nodes
-    const client = createTestNode();
-    const { nodeToServerPeer } = connectNodeToSyncServer(client);
+    const client = setupTestNode({ connected: true });
+    const { peerState } = client.connectToSyncServer();
 
     // Create test data
-    const group = client.createGroup();
+    const group = client.node.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    await client.syncManager.actuallySyncCoValue(map.core);
+    await client.node.syncManager.actuallySyncCoValue(map.core);
 
-    const subscriptionManager = client.syncManager.syncState;
+    const subscriptionManager = client.node.syncManager.syncState;
 
     expect(
-      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+      subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
         .uploaded,
     ).toBe(false);
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(
-        nodeToServerPeer.id,
-        map.core.id,
-      ).uploaded;
+      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
+        .uploaded;
     });
 
     expect(
-      subscriptionManager.getCurrentSyncState(nodeToServerPeer.id, map.core.id)
+      subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
         .uploaded,
     ).toBe(true);
   });
 
   test("unsubscribe stops receiving updates", async () => {
     // Setup nodes
-    const client = createTestNode();
-    const { nodeToServerPeer } = connectNodeToSyncServer(client);
+    const client = setupTestNode({ connected: true });
+    const { peerState } = client.connectToSyncServer();
 
     // Create test data
-    const group = client.createGroup();
+    const group = client.node.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
 
-    const subscriptionManager = client.syncManager.syncState;
+    const subscriptionManager = client.node.syncManager.syncState;
     const anyUpdateSpy = vi.fn();
     const unsubscribe1 = subscriptionManager.subscribeToUpdates(anyUpdateSpy);
     const unsubscribe2 = subscriptionManager.subscribeToPeerUpdates(
-      nodeToServerPeer.id,
+      peerState.id,
       anyUpdateSpy,
     );
 
     unsubscribe1();
     unsubscribe2();
 
-    await client.syncManager.actuallySyncCoValue(map.core);
+    await client.node.syncManager.actuallySyncCoValue(map.core);
 
     anyUpdateSpy.mockClear();
 
     await waitFor(() => {
-      return subscriptionManager.getCurrentSyncState(
-        nodeToServerPeer.id,
-        map.core.id,
-      ).uploaded;
+      return subscriptionManager.getCurrentSyncState(peerState.id, map.core.id)
+        .uploaded;
     });
 
     expect(anyUpdateSpy).not.toHaveBeenCalled();
@@ -194,22 +187,20 @@ describe("SyncStateManager", () => {
 
   test("getCurrentSyncState should return the correct state", async () => {
     // Setup nodes
-    const clientNode = createTestNode();
-    const serverNode = jazzCloud;
-    const {
-      nodeToServerPeer: clientToServerPeer,
-      serverToNodePeer: serverToClientPeer,
-    } = connectNodeToSyncServer(clientNode);
+    const client = setupTestNode({ connected: true });
+    const serverNode = jazzCloud.node;
+    const { peer, peerOnServer } = client.connectToSyncServer();
+
     // Create test data
-    const group = clientNode.createGroup();
+    const group = client.node.createGroup();
     const map = group.createMap();
     map.set("key1", "value1", "trusting");
     group.addMember("everyone", "writer");
 
     // Initially should not be synced
     expect(
-      clientNode.syncManager.syncState.getCurrentSyncState(
-        clientToServerPeer.id,
+      client.node.syncManager.syncState.getCurrentSyncState(
+        peer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: false });
@@ -218,8 +209,8 @@ describe("SyncStateManager", () => {
     await map.core.waitForSync();
 
     expect(
-      clientNode.syncManager.syncState.getCurrentSyncState(
-        clientToServerPeer.id,
+      client.node.syncManager.syncState.getCurrentSyncState(
+        peer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
@@ -227,23 +218,20 @@ describe("SyncStateManager", () => {
     const mapOnServer = await loadCoValueOrFail(serverNode, map.id);
 
     // Block the content messages so the client won't fully sync immediately
-    const outgoing = blockMessageTypeOnOutgoingPeer(
-      serverToClientPeer,
-      "content",
-    );
+    const outgoing = blockMessageTypeOnOutgoingPeer(peerOnServer, "content");
 
     mapOnServer.set("key2", "value2", "trusting");
 
     expect(
-      clientNode.syncManager.syncState.getCurrentSyncState(
-        clientToServerPeer.id,
+      client.node.syncManager.syncState.getCurrentSyncState(
+        peer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
       serverNode.syncManager.syncState.getCurrentSyncState(
-        serverToClientPeer.id,
+        peerOnServer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: false });
@@ -254,15 +242,15 @@ describe("SyncStateManager", () => {
     await mapOnServer.core.waitForSync();
 
     expect(
-      clientNode.syncManager.syncState.getCurrentSyncState(
-        clientToServerPeer.id,
+      client.node.syncManager.syncState.getCurrentSyncState(
+        peer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });
 
     expect(
       serverNode.syncManager.syncState.getCurrentSyncState(
-        serverToClientPeer.id,
+        peerOnServer.id,
         map.core.id,
       ),
     ).toEqual({ uploaded: true });

package/src/tests/coValueCore.test.ts

@@ -1,4 +1,4 @@
-import { expect, test, vi } from "vitest";
+import { assert, afterEach, beforeEach, expect, test, vi } from "vitest";
 import { CoValueCore, Transaction } from "../coValueCore.js";
 import { MapOpPayload } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
@@ -6,14 +6,26 @@ import { stableStringify } from "../jsonStringify.js";
 import { LocalNode } from "../localNode.js";
 import { Role } from "../permissions.js";
 import {
+  createTestMetricReader,
   createTestNode,
   createTwoConnectedNodes,
   loadCoValueOrFail,
   randomAnonymousAccountAndSessionID,
+  tearDownTestMetricReader,
 } from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
+let metricReader: ReturnType<typeof createTestMetricReader>;
+
+beforeEach(() => {
+  metricReader = createTestMetricReader();
+});
+
+afterEach(() => {
+  tearDownTestMetricReader();
+});
+
 test("Can create coValue with new agent credentials and add transaction to it", () => {
   const [account, sessionID] = randomAnonymousAccountAndSessionID();
   const node = new LocalNode(account, sessionID, Crypto);
@@ -197,6 +209,63 @@ test("New transactions in a group correctly update owned values, including subsc
   expect(map.core.getValidSortedTransactions().length).toBe(0);
 });
 
+test("correctly records transactions", async () => {
+  const [account, sessionID] = randomAnonymousAccountAndSessionID();
+  const node = new LocalNode(account, sessionID, Crypto);
+
+  const changes1 = stableStringify([{ hello: "world" }]);
+  node.syncManager.recordTransactionsSize(
+    [
+      {
+        privacy: "trusting",
+        changes: changes1,
+        madeAt: Date.now(),
+      },
+    ],
+    "server",
+  );
+
+  let value = await metricReader.getMetricValue("jazz.transactions.size", {
+    source: "server",
+  });
+  assert(typeof value !== "number" && !!value?.count);
+  expect(value.count).toBe(1);
+  expect(value.sum).toBe(changes1.length);
+
+  const changes2 = stableStringify([{ foo: "bar" }]);
+  node.syncManager.recordTransactionsSize(
+    [
+      {
+        privacy: "trusting",
+        changes: changes2,
+        madeAt: Date.now(),
+      },
+    ],
+    "server",
+  );
+
+  value = await metricReader.getMetricValue("jazz.transactions.size", {
+    source: "server",
+  });
+  assert(typeof value !== "number" && !!value?.count);
+  expect(value.count).toBe(2);
+  expect(value.sum).toBe(changes1.length + changes2.length);
+});
+
+test("(smoke test) records transactions from local node", async () => {
+  const [account, sessionID] = randomAnonymousAccountAndSessionID();
+  const node = new LocalNode(account, sessionID, Crypto);
+
+  node.createGroup();
+
+  let value = await metricReader.getMetricValue("jazz.transactions.size", {
+    source: "local",
+  });
+
+  assert(typeof value !== "number" && !!value?.count);
+  expect(value.count).toBe(3);
+});
+
 test("creating a coValue with a group should't trigger automatically a content creation (performance)", () => {
   const node = createTestNode();
 
@@ -218,12 +287,30 @@ test("creating a coValue with a group should't trigger automatically a content c
   });
 
   // It's called once for the group and never for the coValue
-  expect(getCurrentContentSpy).toHaveBeenCalledTimes(1);
-  expect(groupSpy).toHaveBeenCalledTimes(1);
+  expect(getCurrentContentSpy).toHaveBeenCalledTimes(0);
+  expect(groupSpy).toHaveBeenCalledTimes(0);
 
   getCurrentContentSpy.mockRestore();
 });
 
+test("loading a coValue core without having the owner group available doesn't crash", () => {
+  const [account, sessionID] = randomAnonymousAccountAndSessionID();
+  const node = new LocalNode(account, sessionID, Crypto);
+
+  const otherNode = createTestNode();
+
+  const group = otherNode.createGroup();
+
+  const coValue = node.createCoValue({
+    type: "costream",
+    ruleset: { type: "ownedByGroup", group: group.id },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  expect(coValue.id).toBeDefined();
+});
+
 test("listeners are notified even if the previous listener threw an error", async () => {
   const { node1, node2 } = await createTwoConnectedNodes("server", "server");
 

package/src/tests/coValueState.test.ts

@@ -1,9 +1,19 @@
-import { beforeEach, describe, expect, onTestFinished, test, vi } from "vitest";
+import {
+  assert,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  onTestFinished,
+  test,
+  vi,
+} from "vitest";
 import { PeerState } from "../PeerState";
 import { CoValueCore } from "../coValueCore";
 import { CO_VALUE_LOADING_CONFIG, CoValueState } from "../coValueState";
 import { RawCoID } from "../ids";
 import { Peer } from "../sync";
+import { createTestMetricReader, tearDownTestMetricReader } from "./testUtils";
 
 const initialMaxRetries = CO_VALUE_LOADING_CONFIG.MAX_RETRIES;
 
@@ -15,26 +25,43 @@ function mockMaxRetries(maxRetries: number) {
   });
 }
 
+let metricReader: ReturnType<typeof createTestMetricReader>;
+
 beforeEach(() => {
+  metricReader = createTestMetricReader();
   mockMaxRetries(5);
 });
 
+afterEach(() => {
+  tearDownTestMetricReader();
+});
+
 describe("CoValueState", () => {
   const mockCoValueId = "co_test123" as RawCoID;
 
-  test("should create unknown state", () => {
+  test("should create unknown state", async () => {
     const state = CoValueState.Unknown(mockCoValueId);
 
     expect(state.id).toBe(mockCoValueId);
     expect(state.state.type).toBe("unknown");
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "unknown",
+      }),
+    ).toBe(1);
   });
 
-  test("should create loading state", () => {
+  test("should create loading state", async () => {
     const peerIds = ["peer1", "peer2"];
     const state = CoValueState.Loading(mockCoValueId, peerIds);
 
     expect(state.id).toBe(mockCoValueId);
     expect(state.state.type).toBe("loading");
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(1);
   });
 
   test("should create available state", async () => {
@@ -42,15 +69,31 @@ describe("CoValueState", () => {
     const state = CoValueState.Available(mockCoValue);
 
     expect(state.id).toBe(mockCoValueId);
-    expect(state.state.type).toBe("available");
-    expect((state.state as any).coValue).toBe(mockCoValue);
+    assert(state.state.type === "available");
+    expect(state.state.coValue).toBe(mockCoValue);
     await expect(state.getCoValue()).resolves.toEqual(mockCoValue);
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "available",
+      }),
+    ).toBe(1);
   });
 
   test("should handle found action", async () => {
     const mockCoValue = createMockCoValueCore(mockCoValueId);
     const state = CoValueState.Loading(mockCoValueId, ["peer1", "peer2"]);
 
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "available",
+      }),
+    ).toBe(undefined);
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(1);
+
     const stateValuePromise = state.getCoValue();
 
     state.dispatch({
@@ -61,6 +104,17 @@ describe("CoValueState", () => {
     const result = await state.getCoValue();
     expect(result).toBe(mockCoValue);
     await expect(stateValuePromise).resolves.toBe(mockCoValue);
+
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "available",
+      }),
+    ).toBe(1);
+    expect(
+      await metricReader.getMetricValue("jazz.covalues.loaded", {
+        state: "loading",
+      }),
+    ).toBe(0);
   });
 
   test("should ignore actions when not in loading state", () => {