cojson 0.13.16 → 0.13.18

package/src/tests/coList.test.ts

@@ -1,13 +1,24 @@
-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 { expectGroup } from "../typeUtils/expectGroup.js";
+import {
+  loadCoValueOrFail,
+  nodeWithRandomAgentAndSessionID,
+  randomAgentAndSessionID,
+  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);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -23,7 +34,7 @@ test("Empty CoList works", () => {
 });
 
 test("Can append, prepend, delete and replace items in CoList", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -54,7 +65,7 @@ test("Can append, prepend, delete and replace items in CoList", () => {
 });
 
 test("Push is equivalent to append after last item", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -76,7 +87,7 @@ test("Push is equivalent to append after last item", () => {
 });
 
 test("appendItems add an array of items at the end of the list", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -96,7 +107,7 @@ test("appendItems add an array of items at the end of the list", () => {
 });
 
 test("appendItems at index", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -126,7 +137,7 @@ test("appendItems at index", () => {
 });
 
 test("appendItems at index", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -148,7 +159,7 @@ test("appendItems at index", () => {
 });
 
 test("appendItems with negative index", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -166,7 +177,7 @@ test("appendItems with negative index", () => {
 });
 
 test("Can push into empty list", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -184,7 +195,7 @@ test("Can push into empty list", () => {
 });
 
 test("init the list correctly", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const group = node.createGroup();
 
@@ -204,7 +215,7 @@ test("init the list correctly", () => {
 });
 
 test("Items prepended to start appear with latest first", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "colist",
@@ -221,3 +232,180 @@ test("Items prepended to start appear with latest first", () => {
 
   expect(content.toJSON()).toEqual(["third", "second", "first"]);
 });
+
+test("mixing prepend and append", () => {
+  const node = nodeWithRandomAgentAndSessionID();
+
+  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 = nodeWithRandomAgentAndSessionID();
+
+  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({
+    ourName: "otherClient",
+  });
+
+  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({
+    ourName: "otherClient",
+  });
+
+  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,15 +1,24 @@
-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,
+  nodeWithRandomAgentAndSessionID,
+  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);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -26,7 +35,7 @@ test("Empty CoMap works", () => {
 });
 
 test("Can insert and delete CoMap entries in edit()", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -50,7 +59,7 @@ test("Can insert and delete CoMap entries in edit()", () => {
 });
 
 test("Can get CoMap entry values at different points in time", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -100,7 +109,7 @@ test("Can get CoMap entry values at different points in time", () => {
 });
 
 test("Can get all historic values of key in CoMap", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -124,25 +133,25 @@ test("Can get all historic values of key in CoMap", () => {
   expect([...content.editsAt("hello")]).toEqual([
     {
       tx: editA!.tx,
-      by: node.account.id,
+      by: node.getCurrentAgent().id,
       value: "A",
       at: editA?.at,
     },
     {
       tx: editB!.tx,
-      by: node.account.id,
+      by: node.getCurrentAgent().id,
       value: "B",
       at: editB?.at,
     },
     {
       tx: editDel!.tx,
-      by: node.account.id,
+      by: node.getCurrentAgent().id,
       value: undefined,
       at: editDel?.at,
     },
     {
       tx: editC!.tx,
-      by: node.account.id,
+      by: node.getCurrentAgent().id,
       value: "C",
       at: editC?.at,
     },
@@ -150,7 +159,7 @@ test("Can get all historic values of key in CoMap", () => {
 });
 
 test("Can get last tx ID for a key in CoMap", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -167,7 +176,7 @@ test("Can get last tx ID for a key in CoMap", () => {
   content.set("hello", "A", "trusting");
   const sessionID = content.lastEditAt("hello")?.tx.sessionID;
   expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-    node.account.id,
+    node.getCurrentAgent().id,
   );
   expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
   content.set("hello", "B", "trusting");
@@ -177,7 +186,7 @@ test("Can get last tx ID for a key in CoMap", () => {
 });
 
 test("Can set items in bulk with assign", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "comap",
@@ -207,3 +216,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/coPlainText.test.ts

@@ -2,7 +2,10 @@ import { afterEach, expect, test, vi } from "vitest";
 import { expectPlainText } from "../coValue.js";
 import { WasmCrypto } from "../crypto/WasmCrypto.js";
 import { LocalNode } from "../localNode.js";
-import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import {
+  nodeWithRandomAgentAndSessionID,
+  randomAgentAndSessionID,
+} from "./testUtils.js";
 
 const Crypto = await WasmCrypto.create();
 
@@ -13,7 +16,7 @@ test("should throw on creation if Intl.Segmenter is not available", () => {
     Segmenter: undefined,
   });
 
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
   const group = node.createGroup();
   expect(() => group.createPlainText()).toThrow(
     "Intl.Segmenter is not supported. Use a polyfill to get coPlainText support in Jazz. (eg. https://formatjs.github.io/docs/polyfills/intl-segmenter/)",
@@ -21,7 +24,7 @@ test("should throw on creation if Intl.Segmenter is not available", () => {
 });
 
 test("Empty CoPlainText works", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "coplaintext",
@@ -37,7 +40,7 @@ test("Empty CoPlainText works", () => {
 });
 
 test("Can insert into empty CoPlainText", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "coplaintext",
@@ -55,7 +58,7 @@ test("Can insert into empty CoPlainText", () => {
 });
 
 test("Can insert and delete in CoPlainText", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "coplaintext",
@@ -88,7 +91,7 @@ test("Can insert and delete in CoPlainText", () => {
 });
 
 test("Multiple items inserted appear in correct order", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "coplaintext",
@@ -109,7 +112,7 @@ test("Multiple items inserted appear in correct order", () => {
 });
 
 test("Items inserted at start appear with latest first", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   const coValue = node.createCoValue({
     type: "coplaintext",
@@ -131,7 +134,7 @@ test("Items inserted at start appear with latest first", () => {
 });
 
 test("Handles different locales correctly", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
 
   // Test with explicit locale in meta
   const coValueJa = node.createCoValue({
@@ -175,7 +178,7 @@ test("Handles different locales correctly", () => {
 });
 
 test("insertBefore and insertAfter work as expected", () => {
-  const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+  const node = nodeWithRandomAgentAndSessionID();
   const coValue = node.createCoValue({
     type: "coplaintext",
     ruleset: { type: "unsafeAllowAll" },