cojson 0.18.34 → 0.18.36

package/src/tests/coValueContentMessage.test.ts

@@ -1,10 +1,15 @@
 import { describe, expect, test } from "vitest";
-import { knownStateFromContent } from "../coValueContentMessage.js";
+import {
+  getNewTransactionsFromContentMessage,
+  knownStateFromContent,
+} from "../coValueContentMessage.js";
 import { emptyKnownState } from "../knownState.js";
-import { NewContentMessage } from "../sync.js";
+import { NewContentMessage, SessionNewContent } from "../sync.js";
 import type { RawCoID, SessionID } from "../ids.js";
 import { stableStringify } from "../jsonStringify.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { CoValueKnownState } from "../knownState.js";
+import { Transaction } from "../coValueCore/verifiedState.js";
 
 describe("knownStateFromContent", () => {
   const mockCoID: RawCoID = "co_z1234567890abcdef";
@@ -213,3 +218,193 @@ describe("knownStateFromContent", () => {
     expect(result.sessions[mockSessionID1]).toBe(1); // 0 + 1
   });
 });
+
+describe("getNewTransactionsFromContentMessage", () => {
+  const mockCoID: RawCoID = "co_z1234567890abcdef";
+  const mockSessionID: SessionID = "sealer_z123/signer_z456_session_z789";
+
+  function createTransaction(): Transaction {
+    return {
+      privacy: "trusting",
+      madeAt: Date.now(),
+      changes: stableStringify([{ op: "set", key: "test", value: "value" }]),
+    };
+  }
+
+  function createKnownState(
+    sessionTxIdx: number | undefined,
+  ): CoValueKnownState {
+    const knownState = emptyKnownState(mockCoID);
+    knownState.header = true;
+    if (sessionTxIdx !== undefined) {
+      knownState.sessions[mockSessionID] = sessionTxIdx;
+    }
+    return knownState;
+  }
+
+  test("returns all transactions when we know none (ourKnownTxIdx = 0, theirFirstNewTxIdx = 0)", () => {
+    const transactions = [createTransaction(), createTransaction()];
+    const content: SessionNewContent = {
+      after: 0,
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(undefined); // defaults to 0
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual(transactions);
+    expect(result).toHaveLength(2);
+  });
+
+  test("returns subset of transactions when we know some (ourKnownTxIdx = 3, theirFirstNewTxIdx = 0)", () => {
+    const transactions = [
+      createTransaction(),
+      createTransaction(),
+      createTransaction(),
+      createTransaction(),
+      createTransaction(),
+    ];
+    const content: SessionNewContent = {
+      after: 0,
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(3); // we already know txs 0, 1, 2
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual(transactions.slice(3));
+    expect(result).toHaveLength(2);
+  });
+
+  test("returns undefined when we're missing transactions (ourKnownTxIdx = 2, theirFirstNewTxIdx = 5)", () => {
+    const transactions = [createTransaction(), createTransaction()];
+    const content: SessionNewContent = {
+      after: 5, // they're sending txs starting from idx 5
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(2); // but we only know up to idx 2
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toBeUndefined();
+  });
+
+  test("returns empty array when we know all transactions (ourKnownTxIdx = 5, theirFirstNewTxIdx = 2)", () => {
+    const transactions = [
+      createTransaction(),
+      createTransaction(),
+      createTransaction(),
+    ];
+    const content: SessionNewContent = {
+      after: 2, // they're sending txs 2, 3, 4
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(5); // we already know txs up to idx 5
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual([]);
+    expect(result).toHaveLength(0);
+  });
+
+  test("returns all transactions when ourKnownTxIdx equals theirFirstNewTxIdx", () => {
+    const transactions = [createTransaction(), createTransaction()];
+    const content: SessionNewContent = {
+      after: 3,
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(3); // we know up to idx 3
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual(transactions);
+    expect(result).toHaveLength(2);
+  });
+
+  test("handles session not in knownState (defaults to 0)", () => {
+    const transactions = [createTransaction()];
+    const content: SessionNewContent = {
+      after: 1,
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = emptyKnownState(mockCoID);
+    knownState.header = true;
+    // no sessions defined, so mockSessionID defaults to 0
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    // ourKnownTxIdx = 0, theirFirstNewTxIdx = 1, so 0 < 1 -> undefined
+    expect(result).toBeUndefined();
+  });
+
+  test("returns single transaction when offset is length - 1", () => {
+    const transactions = [
+      createTransaction(),
+      createTransaction(),
+      createTransaction(),
+    ];
+    const content: SessionNewContent = {
+      after: 5,
+      newTransactions: transactions,
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(7); // we know up to idx 7 (5 + 2 transactions)
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual([transactions[2]]);
+    expect(result).toHaveLength(1);
+  });
+
+  test("handles empty newTransactions array", () => {
+    const content: SessionNewContent = {
+      after: 5,
+      newTransactions: [],
+      lastSignature: "signature_z1234",
+    };
+    const knownState = createKnownState(5);
+
+    const result = getNewTransactionsFromContentMessage(
+      content,
+      knownState,
+      mockSessionID,
+    );
+
+    expect(result).toEqual([]);
+    expect(result).toHaveLength(0);
+  });
+});

package/src/tests/coValueCore.test.ts

@@ -78,14 +78,13 @@ test("transactions with wrong signature are rejected", () => {
 
   const newEntry = node.getCoValue(coValue.id);
 
-  // eslint-disable-next-line neverthrow/must-use-result
-  const result = newEntry.tryAddTransactions(
+  const error = newEntry.tryAddTransactions(
     node.currentSessionID,
     [transaction],
     signature,
   );
 
-  expect(result.isErr()).toBe(true);
+  expect(Boolean(error)).toBe(true);
   expect(newEntry.getValidSortedTransactions().length).toBe(0);
 });
 
@@ -448,13 +447,11 @@ test("getValidTransactions should skip private transactions with invalid JSON",
   map.set("hello", "world");
 
   // This should fail silently, because the encryptedChanges will be outputted as gibberish
-  map.core
-    .tryAddTransactions(
-      fixtures.session,
-      [fixtures.transaction],
-      fixtures.signature,
-    )
-    ._unsafeUnwrap();
+  map.core.tryAddTransactions(
+    fixtures.session,
+    [fixtures.transaction],
+    fixtures.signature,
+  );
 
   // Get valid transactions - should only include the valid one
   const validTransactions = map.core.getValidTransactions();

package/src/tests/group.childKeyRotation.test.ts

@@ -69,7 +69,7 @@ describe("Group.childKeyRotation", () => {
     expect(mapOnAliceNode.get("test")).toBeUndefined();
   });
 
-  test("removing a member should rotate the readKey on unloaded child groups", async () => {
+  test.skip("removing a member should rotate the readKey on unloaded child groups", async () => {
     const group = admin.node.createGroup();
 
     let childGroup = bob.node.createGroup();
@@ -103,7 +103,7 @@ describe("Group.childKeyRotation", () => {
     expect(mapOnAliceNode.get("test")).toBeUndefined();
   });
 
-  test("removing a member on a large group should rotate the readKey on unloaded child group", async () => {
+  test.skip("removing a member on a large group should rotate the readKey on unloaded child group", async () => {
     const group = admin.node.createGroup();
 
     const childGroup = bob.node.createGroup();
@@ -163,7 +163,7 @@ describe("Group.childKeyRotation", () => {
     expect(mapOnAliceNode.get("test")).toBeUndefined();
   });
 
-  test("removing a member on a large parent group should rotate the readKey on unloaded grandChild group", async () => {
+  test.skip("removing a member on a large parent group should rotate the readKey on unloaded grandChild group", async () => {
     const parentGroup = admin.node.createGroup();
 
     const group = bob.node.createGroup();
@@ -230,7 +230,7 @@ describe("Group.childKeyRotation", () => {
     expect(mapOnAliceNode.get("test")).toBeUndefined();
   });
 
-  test("non-admin accounts can't trigger the unloaded child group key rotation", async () => {
+  test.skip("non-admin accounts can't trigger the unloaded child group key rotation", async () => {
     const group = admin.node.createGroup();
     const childGroup = bob.node.createGroup();
 
@@ -290,7 +290,7 @@ describe("Group.childKeyRotation", () => {
     expect(updatedMapOnCharlieNode.get("test")).toBe("Readable by charlie");
   });
 
-  test("direct manager account can trigger the unloaded child group key rotation", async () => {
+  test.skip("direct manager account can trigger the unloaded child group key rotation", async () => {
     const group = admin.node.createGroup();
     const childGroup = bob.node.createGroup();
 
@@ -338,7 +338,7 @@ describe("Group.childKeyRotation", () => {
     expect(mapOnAliceNode.get("test")).toBeUndefined();
   });
 
-  test("inherited admin account triggers the unloaded child group key rotation", async () => {
+  test.skip("inherited admin account triggers the unloaded child group key rotation", async () => {
     const group = admin.node.createGroup();
     const childGroup = bob.node.createGroup();