cojson 0.7.0-alpha.29 → 0.7.0-alpha.36

package/src/tests/coMap.test.ts

@@ -0,0 +1,167 @@
+import { expect, test, beforeEach } from "vitest";
+import { expectList, expectMap, expectStream } from "../coValue.js";
+import { RawBinaryCoStream } from "../coValues/coStream.js";
+import { createdNowUnique } from "../crypto.js";
+import { MAX_RECOMMENDED_TX_SIZE, cojsonReady } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { accountOrAgentIDfromSessionID } from "../typeUtils/accountOrAgentIDfromSessionID.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+
+import { webcrypto } from "node:crypto";
+if (!("crypto" in globalThis)) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (globalThis as any).crypto = webcrypto;
+}
+
+beforeEach(async () => {
+    await cojsonReady;
+});
+
+
+test("Empty CoMap works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+    expect([...content.keys()]).toEqual([]);
+    expect(content.toJSON()).toEqual({});
+});
+
+test("Can insert and delete CoMap entries in edit()", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    content.set("hello", "world", "trusting");
+    expect(content.get("hello")).toEqual("world");
+    content.set("foo", "bar", "trusting");
+    expect(content.get("foo")).toEqual("bar");
+    expect([...content.keys()]).toEqual(["hello", "foo"]);
+    content.delete("foo", "trusting");
+    expect(content.get("foo")).toEqual(undefined);
+    expect(content.keys()).toEqual(["hello"]);
+});
+
+test("Can get CoMap entry values at different points in time", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    const beforeA = Date.now();
+    while (Date.now() < beforeA + 10) {}
+    content.set("hello", "A", "trusting");
+    const beforeB = Date.now();
+    while (Date.now() < beforeB + 10) {}
+    content.set("hello", "B", "trusting");
+    const beforeC = Date.now();
+    while (Date.now() < beforeC + 10) {}
+    content.set("hello", "C", "trusting");
+    expect(content.get("hello")).toEqual("C");
+    expect(content.atTime(Date.now()).get("hello")).toEqual("C");
+    expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
+    expect(content.atTime(beforeB).get("hello")).toEqual("A");
+    expect(content.atTime(beforeC).get("hello")).toEqual("B");
+});
+
+test("Can get all historic values of key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    content.set("hello", "A", "trusting");
+    const editA = content.lastEditAt("hello");
+    content.set("hello", "B", "trusting");
+    const editB = content.lastEditAt("hello");
+    content.delete("hello", "trusting");
+    const editDel = content.lastEditAt("hello");
+    content.set("hello", "C", "trusting");
+    const editC = content.lastEditAt("hello");
+    expect([...content.editsAt("hello")]).toEqual([
+        {
+            tx: editA!.tx,
+            by: node.account.id,
+            value: "A",
+            at: editA?.at,
+        },
+        {
+            tx: editB!.tx,
+            by: node.account.id,
+            value: "B",
+            at: editB?.at,
+        },
+        {
+            tx: editDel!.tx,
+            by: node.account.id,
+            value: undefined,
+            at: editDel?.at,
+        },
+        {
+            tx: editC!.tx,
+            by: node.account.id,
+            value: "C",
+            at: editC?.at,
+        },
+    ]);
+});
+
+test("Can get last tx ID for a key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = expectMap(coValue.getCurrentContent());
+
+    expect(content.type).toEqual("comap");
+
+    expect(content.lastEditAt("hello")).toEqual(undefined);
+    content.set("hello", "A", "trusting");
+    const sessionID = content.lastEditAt("hello")?.tx.sessionID;
+    expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+        node.account.id
+    );
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
+    content.set("hello", "B", "trusting");
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
+    content.set("hello", "C", "trusting");
+    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
+});

package/src/tests/{coValue.test.ts → coStream.test.ts}

@@ -17,236 +17,6 @@ beforeEach(async () => {
     await cojsonReady;
 });
 
-test("Empty CoMap works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-    expect([...content.keys()]).toEqual([]);
-    expect(content.toJSON()).toEqual({});
-});
-
-test("Can insert and delete CoMap entries in edit()", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    content.set("hello", "world", "trusting");
-    expect(content.get("hello")).toEqual("world");
-    content.set("foo", "bar", "trusting");
-    expect(content.get("foo")).toEqual("bar");
-    expect([...content.keys()]).toEqual(["hello", "foo"]);
-    content.delete("foo", "trusting");
-    expect(content.get("foo")).toEqual(undefined);
-    expect(content.keys()).toEqual(["hello"]);
-});
-
-test("Can get CoMap entry values at different points in time", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    const beforeA = Date.now();
-    while (Date.now() < beforeA + 10) {}
-    content.set("hello", "A", "trusting");
-    const beforeB = Date.now();
-    while (Date.now() < beforeB + 10) {}
-    content.set("hello", "B", "trusting");
-    const beforeC = Date.now();
-    while (Date.now() < beforeC + 10) {}
-    content.set("hello", "C", "trusting");
-    expect(content.get("hello")).toEqual("C");
-    expect(content.atTime(Date.now()).get("hello")).toEqual("C");
-    expect(content.atTime(beforeA).get("hello")).toEqual(undefined);
-    expect(content.atTime(beforeB).get("hello")).toEqual("A");
-    expect(content.atTime(beforeC).get("hello")).toEqual("B");
-});
-
-test("Can get all historic values of key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    content.set("hello", "A", "trusting");
-    const editA = content.lastEditAt("hello");
-    content.set("hello", "B", "trusting");
-    const editB = content.lastEditAt("hello");
-    content.delete("hello", "trusting");
-    const editDel = content.lastEditAt("hello");
-    content.set("hello", "C", "trusting");
-    const editC = content.lastEditAt("hello");
-    expect([...content.editsAt("hello")]).toEqual([
-        {
-            tx: editA!.tx,
-            by: node.account.id,
-            value: "A",
-            at: editA?.at,
-        },
-        {
-            tx: editB!.tx,
-            by: node.account.id,
-            value: "B",
-            at: editB?.at,
-        },
-        {
-            tx: editDel!.tx,
-            by: node.account.id,
-            value: undefined,
-            at: editDel?.at,
-        },
-        {
-            tx: editC!.tx,
-            by: node.account.id,
-            value: "C",
-            at: editC?.at,
-        },
-    ]);
-});
-
-test("Can get last tx ID for a key in CoMap", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "comap",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectMap(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("comap");
-
-    expect(content.lastEditAt("hello")).toEqual(undefined);
-    content.set("hello", "A", "trusting");
-    const sessionID = content.lastEditAt("hello")?.tx.sessionID;
-    expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
-        node.account.id
-    );
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(0);
-    content.set("hello", "B", "trusting");
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(1);
-    content.set("hello", "C", "trusting");
-    expect(content.lastEditAt("hello")?.tx.txIndex).toEqual(2);
-});
-
-test("Empty CoList works", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectList(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("colist");
-    expect(content.toJSON()).toEqual([]);
-});
-
-test("Can append, prepend, delete and replace items in CoList", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...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());
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectList(coValue.getCurrentContent());
-
-    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"]);
-});
-
-test("Can push into empty list", () => {
-    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
-
-    const coValue = node.createCoValue({
-        type: "colist",
-        ruleset: { type: "unsafeAllowAll" },
-        meta: null,
-        ...createdNowUnique(),
-    });
-
-    const content = expectList(coValue.getCurrentContent());
-
-    expect(content.type).toEqual("colist");
-
-    content.append("hello", undefined, "trusting");
-    expect(content.toJSON()).toEqual(["hello"]);
-});
-
 test("Empty CoStream works", () => {
     const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
@@ -483,4 +253,4 @@ test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we s
     expect(newContent[4]!.new[node.currentSessionID]!.lastSignature).toEqual(
         sessionEntry.lastSignature
     );
-});
+});