cojson 0.1.8 → 0.1.10

package/src/coValue.test.ts

@@ -1,181 +1,387 @@
-import { Transaction } from "./coValue.js";
+import { accountOrAgentIDfromSessionID } from "./coValueCore.js";
+import { BinaryCoStream } from "./coValues/coStream.js";
+import { createdNowUnique } from "./crypto.js";
 import { LocalNode } from "./node.js";
-import { createdNowUnique, getAgentSignerSecret, newRandomAgentSecret, sign } from "./crypto.js";
 import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
-import { CoMap, MapOpPayload } from "./contentTypes/coMap.js";
-import { AccountID } from "./index.js";
-import { Role } from "./permissions.js";
 
-test("Can create coValue with new agent credentials and add transaction to it", () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Empty CoMap works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
-            {
-                hello: "world",
-            },
-        ],
-    };
-
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.currentSessionID,
-        [transaction]
-    );
-
-    expect(
-        coValue.tryAddTransactions(
-            node.currentSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
-    ).toBe(true);
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+    expect([...content.keys()]).toEqual([]);
+    expect(content.toJSON()).toEqual({});
 });
 
-test("transactions with wrong signature are rejected", () => {
-    const wrongAgent = newRandomAgentSecret();
-    const [agentSecret, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(agentSecret, sessionID);
+test("Can insert and delete CoMap entries in edit()", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
         ruleset: { type: "unsafeAllowAll" },
         meta: null,
         ...createdNowUnique(),
     });
 
-    const transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
-            {
-                hello: "world",
-            },
-        ],
-    };
-
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.currentSessionID,
-        [transaction]
-    );
-
-    expect(
-        coValue.tryAddTransactions(
-            node.currentSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(getAgentSignerSecret(wrongAgent), expectedNewHash)
-        )
-    ).toBe(false);
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        editable.set("hello", "world", "trusting");
+        expect(editable.get("hello")).toEqual("world");
+        editable.set("foo", "bar", "trusting");
+        expect(editable.get("foo")).toEqual("bar");
+        expect([...editable.keys()]).toEqual(["hello", "foo"]);
+        editable.delete("foo", "trusting");
+        expect(editable.get("foo")).toEqual(undefined);
+    });
 });
 
-test("transactions with correctly signed, but wrong hash are rejected", () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Can get CoMap entry values at different points in time", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
     const coValue = node.createCoValue({
-        type: "costream",
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        const beforeA = Date.now();
+        while (Date.now() < beforeA + 10) {}
+        editable.set("hello", "A", "trusting");
+        const beforeB = Date.now();
+        while (Date.now() < beforeB + 10) {}
+        editable.set("hello", "B", "trusting");
+        const beforeC = Date.now();
+        while (Date.now() < beforeC + 10) {}
+        editable.set("hello", "C", "trusting");
+        expect(editable.get("hello")).toEqual("C");
+        expect(editable.getAtTime("hello", Date.now())).toEqual("C");
+        expect(editable.getAtTime("hello", beforeA)).toEqual(undefined);
+        expect(editable.getAtTime("hello", beforeB)).toEqual("A");
+        expect(editable.getAtTime("hello", beforeC)).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 transaction: Transaction = {
-        privacy: "trusting",
-        madeAt: Date.now(),
-        changes: [
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        editable.set("hello", "A", "trusting");
+        const txA = editable.getLastTxID("hello");
+        editable.set("hello", "B", "trusting");
+        const txB = editable.getLastTxID("hello");
+        editable.delete("hello", "trusting");
+        const txDel = editable.getLastTxID("hello");
+        editable.set("hello", "C", "trusting");
+        const txC = editable.getLastTxID("hello");
+        expect(editable.getHistory("hello")).toEqual([
             {
-                hello: "world",
+                txID: txA,
+                value: "A",
+                at: txA && coValue.getTx(txA)?.madeAt,
             },
-        ],
-    };
-
-    const { expectedNewHash } = coValue.expectedNewHashAfter(
-        node.currentSessionID,
-        [
             {
-                privacy: "trusting",
-                madeAt: Date.now(),
-                changes: [
-                    {
-                        hello: "wrong",
-                    },
-                ],
+                txID: txB,
+                value: "B",
+                at: txB && coValue.getTx(txB)?.madeAt,
             },
-        ]
-    );
-
-    expect(
-        coValue.tryAddTransactions(
-            node.currentSessionID,
-            [transaction],
-            expectedNewHash,
-            sign(account.currentSignerSecret(), expectedNewHash)
-        )
-    ).toBe(false);
+            {
+                txID: txDel,
+                value: undefined,
+                at: txDel && coValue.getTx(txDel)?.madeAt,
+            },
+            {
+                txID: txC,
+                value: "C",
+                at: txC && coValue.getTx(txC)?.madeAt,
+            },
+        ]);
+    });
 });
 
-test("New transactions in a group correctly update owned values, including subscriptions", async () => {
-    const [account, sessionID] = randomAnonymousAccountAndSessionID();
-    const node = new LocalNode(account, sessionID);
+test("Can get last tx ID for a key in CoMap", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    const group = node.createGroup();
+    const coValue = node.createCoValue({
+        type: "comap",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
 
-    const timeBeforeEdit = Date.now();
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "comap") {
+        throw new Error("Expected map");
+    }
+
+    expect(content.type).toEqual("comap");
+
+    content.edit((editable) => {
+        expect(editable.getLastTxID("hello")).toEqual(undefined);
+        editable.set("hello", "A", "trusting");
+        const sessionID = editable.getLastTxID("hello")?.sessionID;
+        expect(sessionID && accountOrAgentIDfromSessionID(sessionID)).toEqual(
+            node.account.id
+        );
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(0);
+        editable.set("hello", "B", "trusting");
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(1);
+        editable.set("hello", "C", "trusting");
+        expect(editable.getLastTxID("hello")?.txIndex).toEqual(2);
+    });
+});
+
+test("Empty CoList works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
 
-    let map = group.createMap();
+    const content = coValue.getCurrentContent();
 
-    let mapAfterEdit = map.edit((map) => {
-        map.set("hello", "world");
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+    expect(content.toJSON()).toEqual([]);
+});
+
+test("Can append, prepend and delete items to CoList", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
     });
 
-    const listener = jest.fn().mockImplementation();
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.append(0, "hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+        editable.append(0, "world", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "world"]);
+        editable.prepend(1, "beautiful", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "beautiful", "world"]);
+        editable.prepend(3, "hooray", "trusting");
+        expect(editable.toJSON()).toEqual([
+            "hello",
+            "beautiful",
+            "world",
+            "hooray",
+        ]);
+        editable.delete(2, "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "beautiful", "hooray"]);
+    });
+});
 
-    map.subscribe(listener);
+test("Push is equivalent to append after last item", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    expect(listener.mock.calls[0][0].get("hello")).toBe("world");
+    const coValue = node.createCoValue({
+        type: "colist",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
 
-    const resignationThatWeJustLearnedAbout = {
-        privacy: "trusting",
-        madeAt: timeBeforeEdit,
-        changes: [
-            {
-                op: "set",
-                key: account.id,
-                value: "revoked"
-            } satisfies MapOpPayload<typeof account.id, Role>
-        ]
-    } satisfies Transaction;
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.append(0, "hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+        editable.push("world", "trusting");
+        expect(editable.toJSON()).toEqual(["hello", "world"]);
+        editable.push("hooray", "trusting");
+        expect(editable.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 = coValue.getCurrentContent();
+
+    if (content.type !== "colist") {
+        throw new Error("Expected list");
+    }
+
+    expect(content.type).toEqual("colist");
+
+    content.edit((editable) => {
+        editable.push("hello", "trusting");
+        expect(editable.toJSON()).toEqual(["hello"]);
+    });
+});
+
+test("Empty CoStream works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
 
-    const { expectedNewHash } = group.groupMap.coValue.expectedNewHashAfter(sessionID, [
-        resignationThatWeJustLearnedAbout,
-    ]);
+    if (content.type !== "costream") {
+        throw new Error("Expected stream");
+    }
 
-    const signature = sign(
-        node.account.currentSignerSecret(),
-        expectedNewHash
-    );
+    expect(content.type).toEqual("costream");
+    expect(content.toJSON()).toEqual({});
+    expect(content.getSingleStream()).toEqual(undefined);
+});
 
-    expect(map.coValue.getValidSortedTransactions().length).toBe(1);
+test("Can push into CoStream", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    const manuallyAdddedTxSuccess = group.groupMap.coValue.tryAddTransactions(node.currentSessionID, [resignationThatWeJustLearnedAbout], expectedNewHash, signature);
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: null,
+        ...createdNowUnique(),
+    });
 
-    expect(manuallyAdddedTxSuccess).toBe(true);
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "costream") {
+        throw new Error("Expected stream");
+    }
+
+    content.edit((editable) => {
+        editable.push({ hello: "world" }, "trusting");
+        expect(editable.toJSON()).toEqual({
+            [node.currentSessionID]: [{ hello: "world" }],
+        });
+        editable.push({ foo: "bar" }, "trusting");
+        expect(editable.toJSON()).toEqual({
+            [node.currentSessionID]: [{ hello: "world" }, { foo: "bar" }],
+        });
+        expect(editable.getSingleStream()).toEqual([
+            { hello: "world" },
+            { foo: "bar" },
+        ]);
+    });
+});
+
+test("Empty BinaryCoStream works", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
 
-    expect(listener.mock.calls.length).toBe(2);
-    expect(listener.mock.calls[1][0].get("hello")).toBe(undefined);
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...createdNowUnique(),
+    });
 
-    expect(map.coValue.getValidSortedTransactions().length).toBe(0);
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "costream" || content.meta?.type !== "binary" || !(content instanceof BinaryCoStream)) {
+        throw new Error("Expected binary stream");
+    }
+
+    expect(content.type).toEqual("costream");
+    expect(content.meta.type).toEqual("binary");
+    expect(content.toJSON()).toEqual({});
+    expect(content.getBinaryChunks()).toEqual(undefined);
+});
+
+test("Can push into BinaryCoStream", () => {
+    const node = new LocalNode(...randomAnonymousAccountAndSessionID());
+
+    const coValue = node.createCoValue({
+        type: "costream",
+        ruleset: { type: "unsafeAllowAll" },
+        meta: { type: "binary" },
+        ...createdNowUnique(),
+    });
+
+    const content = coValue.getCurrentContent();
+
+    if (content.type !== "costream" || content.meta?.type !== "binary" || !(content instanceof BinaryCoStream)) {
+        throw new Error("Expected binary stream");
+    }
+
+    content.edit((editable) => {
+        editable.startBinaryStream({mimeType: "text/plain", fileName: "test.txt"}, "trusting");
+        expect(editable.getBinaryChunks()).toEqual({
+            mimeType: "text/plain",
+            fileName: "test.txt",
+            chunks: [],
+            finished: false,
+        });
+    });
 });