cojson 0.13.16 → 0.13.17

package/src/tests/coList.test.ts

@@ -1,11 +1,20 @@
-import { expect, test } from "vitest";
+import { beforeEach, 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 {
+  loadCoValueOrFail,
+  randomAnonymousAccountAndSessionID,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
+beforeEach(async () => {
+  setupTestNode({ isSyncServer: true });
+});
+
 test("Empty CoList works", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
@@ -221,3 +230,176 @@ test("Items prepended to start appear with latest first", () => {
 
   expect(content.toJSON()).toEqual(["third", "second", "first"]);
 });
+
+test("mixing prepend and append", () => {
+  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+  const coValue = node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const list = expectList(coValue.getCurrentContent());
+
+  list.append(2, undefined, "trusting");
+  list.prepend(1, undefined, "trusting");
+  list.append(3, undefined, "trusting");
+
+  expect(list.toJSON()).toEqual([1, 2, 3]);
+});
+
+test("Items appended to start", () => {
+  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("first", 0, "trusting");
+  content.append("second", 0, "trusting");
+  content.append("third", 0, "trusting");
+
+  // This result is correct because "third" is appended after "first"
+  // Using the Array methods this would be the same as doing content.splice(1, 0, "third")
+  expect(content.toJSON()).toEqual(["first", "third", "second"]);
+});
+
+test("syncing appends with an older timestamp", async () => {
+  const client = setupTestNode({
+    connected: true,
+  });
+  const otherClient = setupTestNode({});
+
+  const otherClientConnection = otherClient.connectToSyncServer();
+
+  const coValue = client.node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const list = expectList(coValue.getCurrentContent());
+
+  list.append(1, undefined, "trusting");
+  list.append(2, undefined, "trusting");
+
+  const listOnOtherClient = await loadCoValueOrFail(otherClient.node, list.id);
+
+  otherClientConnection.peerState.gracefulShutdown();
+
+  listOnOtherClient.append(3, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  list.append(4, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  listOnOtherClient.append(5, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  list.append(6, undefined, "trusting");
+
+  otherClient.connectToSyncServer();
+
+  await waitFor(() => {
+    expect(list.toJSON()).toEqual([1, 2, 4, 6, 3, 5]);
+  });
+
+  expect(listOnOtherClient.toJSON()).toEqual(list.toJSON());
+});
+
+test("syncing prepends with an older timestamp", async () => {
+  const client = setupTestNode({
+    connected: true,
+  });
+  const otherClient = setupTestNode({});
+
+  const otherClientConnection = otherClient.connectToSyncServer();
+
+  const coValue = client.node.createCoValue({
+    type: "colist",
+    ruleset: { type: "unsafeAllowAll" },
+    meta: null,
+    ...Crypto.createdNowUnique(),
+  });
+
+  const list = expectList(coValue.getCurrentContent());
+
+  list.prepend(1, undefined, "trusting");
+  list.prepend(2, undefined, "trusting");
+
+  const listOnOtherClient = await loadCoValueOrFail(otherClient.node, list.id);
+
+  otherClientConnection.peerState.gracefulShutdown();
+
+  listOnOtherClient.prepend(3, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  list.prepend(4, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  listOnOtherClient.prepend(5, undefined, "trusting");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  list.prepend(6, undefined, "trusting");
+
+  otherClient.connectToSyncServer();
+
+  await waitFor(() => {
+    expect(list.toJSON()).toEqual([6, 4, 5, 3, 2, 1]);
+  });
+
+  expect(listOnOtherClient.toJSON()).toEqual(list.toJSON());
+});
+
+test("totalValidTransactions should return the number of valid transactions processed", async () => {
+  const client = setupTestNode({
+    connected: true,
+  });
+  const otherClient = setupTestNode({});
+
+  const otherClientConnection = otherClient.connectToSyncServer();
+
+  const group = client.node.createGroup();
+  group.addMember("everyone", "reader");
+
+  const list = group.createList([1, 2]);
+
+  const listOnOtherClient = await loadCoValueOrFail(otherClient.node, list.id);
+
+  otherClientConnection.peerState.gracefulShutdown();
+
+  group.addMember("everyone", "writer");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  listOnOtherClient.append(3, undefined, "trusting");
+
+  expect(listOnOtherClient.toJSON()).toEqual([1, 2]);
+  expect(listOnOtherClient.totalValidTransactions).toEqual(1);
+
+  otherClient.connectToSyncServer();
+
+  await waitFor(() => {
+    expect(listOnOtherClient.core.getCurrentContent().toJSON()).toEqual([
+      1, 2, 3,
+    ]);
+  });
+
+  expect(
+    listOnOtherClient.core.getCurrentContent().totalValidTransactions,
+  ).toEqual(2);
+});

package/src/tests/coMap.test.ts

@@ -1,13 +1,23 @@
-import { expect, test } from "vitest";
+import { beforeEach, expect, test } from "vitest";
 import { expectMap } from "../coValue.js";
 import { operationToEditEntry } from "../coValues/coMap.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
 import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
-import { hotSleep, randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  hotSleep,
+  loadCoValueOrFail,
+  randomAnonymousAccountAndSessionID,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
+beforeEach(async () => {
+  setupTestNode({ isSyncServer: true });
+});
+
 test("Empty CoMap works", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
@@ -207,3 +217,45 @@ test("Can set items in bulk with assign", () => {
     key3: "assign3",
   });
 });
+
+test("totalValidTransactions should return the number of valid transactions processed", async () => {
+  const client = setupTestNode({
+    connected: true,
+  });
+  const otherClient = setupTestNode({});
+
+  const otherClientConnection = otherClient.connectToSyncServer();
+
+  const group = client.node.createGroup();
+  group.addMember("everyone", "reader");
+
+  const map = group.createMap({ fromClient: true });
+
+  const mapOnOtherClient = await loadCoValueOrFail(otherClient.node, map.id);
+
+  otherClientConnection.peerState.gracefulShutdown();
+
+  group.addMember("everyone", "writer");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  mapOnOtherClient.set("fromOtherClient", true, "trusting");
+
+  expect(mapOnOtherClient.totalValidTransactions).toEqual(1);
+  expect(mapOnOtherClient.toJSON()).toEqual({
+    fromClient: true,
+  });
+
+  otherClient.connectToSyncServer();
+
+  await waitFor(() => {
+    expect(mapOnOtherClient.core.getCurrentContent().toJSON()).toEqual({
+      fromClient: true,
+      fromOtherClient: true,
+    });
+  });
+
+  expect(
+    mapOnOtherClient.core.getCurrentContent().totalValidTransactions,
+  ).toEqual(2);
+});

package/src/tests/coStream.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, test } from "vitest";
 import { expectStream } from "../coValue.js";
 import { MAX_RECOMMENDED_TX_SIZE } from "../coValueCore.js";
 import {
@@ -10,10 +10,19 @@ import {
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { SessionID } from "../ids.js";
 import { LocalNode } from "../localNode.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  loadCoValueOrFail,
+  randomAnonymousAccountAndSessionID,
+  setupTestNode,
+  waitFor,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
+beforeEach(async () => {
+  setupTestNode({ isSyncServer: true });
+});
+
 test("Empty CoStream works", () => {
   const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
 
@@ -252,6 +261,51 @@ test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we s
   );
 });
 
+test("totalValidTransactions should return the number of valid transactions processed", async () => {
+  const client = setupTestNode({
+    connected: true,
+  });
+  const otherClient = setupTestNode({});
+
+  const otherClientConnection = otherClient.connectToSyncServer();
+
+  const group = client.node.createGroup();
+  group.addMember("everyone", "reader");
+
+  const stream = group.createStream();
+  stream.push(1, "trusting");
+
+  const streamOnOtherClient = await loadCoValueOrFail(
+    otherClient.node,
+    stream.id,
+  );
+
+  otherClientConnection.peerState.gracefulShutdown();
+
+  group.addMember("everyone", "writer");
+
+  await new Promise((resolve) => setTimeout(resolve, 50));
+
+  streamOnOtherClient.push(2, "trusting");
+
+  expect(streamOnOtherClient.totalValidTransactions).toEqual(1);
+  expect(Object.keys(streamOnOtherClient.toJSON()).length).toEqual(1);
+
+  otherClient.connectToSyncServer();
+
+  await waitFor(() => {
+    expect(
+      Object.keys(
+        streamOnOtherClient.core.getCurrentContent().toJSON() as object,
+      ).length,
+    ).toEqual(2);
+  });
+
+  expect(
+    streamOnOtherClient.core.getCurrentContent().totalValidTransactions,
+  ).toEqual(2);
+});
+
 describe("isBinaryStreamEnded", () => {
   function setup() {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);

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");