cojson 0.7.35-unique.2 → 0.7.35

package/src/tests/PeerState.test.ts

@@ -0,0 +1,92 @@
+import { describe, test, expect, vi } from "vitest";
+import { PeerState } from "../PeerState.js";
+import { Peer, SyncMessage } from "../sync.js";
+import { CO_VALUE_PRIORITY } from "../priority.js";
+
+function setup() {
+    const mockPeer: Peer = {
+        id: "test-peer",
+        role: "peer",
+        priority: 1,
+        crashOnClose: false,
+        incoming: (async function* () {})(),
+        outgoing: {
+            push: vi.fn().mockResolvedValue(undefined),
+            close: vi.fn(),
+        },
+    };
+    const peerState = new PeerState(mockPeer);
+    return { mockPeer, peerState };
+}
+
+describe("PeerState", () => {
+    test("should initialize with correct properties", () => {
+        const { peerState } = setup();
+        expect(peerState.id).toBe("test-peer");
+        expect(peerState.role).toBe("peer");
+        expect(peerState.priority).toBe(1);
+        expect(peerState.crashOnClose).toBe(false);
+        expect(peerState.closed).toBe(false);
+        expect(peerState.optimisticKnownStates).toEqual({});
+        expect(peerState.toldKnownState).toEqual(new Set());
+    });
+
+    test("should push outgoing message to peer", async () => {
+        const { mockPeer, peerState } = setup();
+        const message: SyncMessage = { action: "load", id: "co_ztest-id", header: false, sessions: {} };
+        await peerState.pushOutgoingMessage(message);
+        expect(mockPeer.outgoing.push).toHaveBeenCalledWith(message);
+    });
+
+    test("should return peer's incoming when not closed", () => {
+        const { mockPeer, peerState } = setup();
+        expect(peerState.incoming).toBe(mockPeer.incoming);
+    });
+
+    test("should return Disconnected when closed", async () => {
+        const { peerState } = setup();
+        peerState.gracefulShutdown();
+        const incomingIterator = peerState.incoming[Symbol.asyncIterator]();
+        const { value, done } = await incomingIterator.next();
+        expect(value).toBe("Disconnected");
+        expect(done).toBe(false);
+    });
+
+    test("should perform graceful shutdown", () => {
+        const { mockPeer, peerState } = setup();
+        const consoleSpy = vi.spyOn(console, "debug").mockImplementation(() => {});
+        peerState.gracefulShutdown();
+        expect(mockPeer.outgoing.close).toHaveBeenCalled();
+        expect(peerState.closed).toBe(true);
+        expect(consoleSpy).toHaveBeenCalledWith("Gracefully closing", "test-peer");
+        consoleSpy.mockRestore();
+    });
+
+    test("should schedule outgoing messages based on their priority", async () => {
+        const { peerState } = setup();
+
+        const loadMessage: SyncMessage = { action: "load", id: "co_zhigh", header: false, sessions: {} };
+        const contentMessageHigh: SyncMessage = { action: "content", id: "co_zhigh", new: {}, priority: CO_VALUE_PRIORITY.HIGH };
+        const contentMessageMid: SyncMessage = { action: "content", id: "co_zmid", new: {}, priority: CO_VALUE_PRIORITY.MEDIUM };
+        const contentMessageLow: SyncMessage = { action: "content", id: "co_zlow", new: {}, priority: CO_VALUE_PRIORITY.LOW };
+
+        const promises = [
+            peerState.pushOutgoingMessage(contentMessageLow),
+            peerState.pushOutgoingMessage(contentMessageMid),
+            peerState.pushOutgoingMessage(contentMessageHigh),
+            peerState.pushOutgoingMessage(loadMessage),
+        ];
+
+        await Promise.all(promises);
+
+        // The first message is pushed directly, the other three are queued because are waiting
+        // for the first push to be completed.
+        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(1, contentMessageLow); 
+
+        // Load message are managed as high priority messages and having the same priority as the content message
+        // they follow the push order.
+        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(2, contentMessageHigh);
+        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(3, loadMessage);
+        expect(peerState["peer"].outgoing.push).toHaveBeenNthCalledWith(4, contentMessageMid);
+    });
+});

package/src/tests/PriorityBasedMessageQueue.test.ts

@@ -0,0 +1,111 @@
+import { describe, test, expect } from "vitest";
+import { PriorityBasedMessageQueue } from "../PriorityBasedMessageQueue.js";
+import { SyncMessage } from "../sync.js";
+import { CO_VALUE_PRIORITY } from "../priority.js";
+
+function setup() {
+    const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
+    return { queue };
+}
+
+describe("PriorityBasedMessageQueue", () => {
+    test("should initialize with correct properties", () => {
+        const { queue } = setup();
+        expect(queue["defaultPriority"]).toBe(CO_VALUE_PRIORITY.MEDIUM);
+        expect(queue["queues"].length).toBe(8);
+        expect(queue["queues"].every((q) => q.length === 0)).toBe(true);
+    });
+
+    test("should push message with default priority", async () => {
+        const { queue } = setup();
+        const message: SyncMessage = {
+            action: "load",
+            id: "co_ztest-id",
+            header: false,
+            sessions: {},
+        };
+        void queue.push(message);
+        const pulledEntry = queue.pull();
+        expect(pulledEntry?.msg).toEqual(message);
+    });
+
+    test("should push message with specified priority", async () => {
+        const { queue } = setup();
+        const message: SyncMessage = {
+            action: "content",
+            id: "co_zhigh",
+            new: {},
+            priority: CO_VALUE_PRIORITY.HIGH,
+        };
+        void queue.push(message);
+        const pulledEntry = queue.pull();
+        expect(pulledEntry?.msg).toEqual(message);
+    });
+
+    test("should pull messages in priority order", async () => {
+        const { queue } = setup();
+        const lowPriorityMsg: SyncMessage = {
+            action: "content",
+            id: "co_zlow",
+            new: {},
+            priority: CO_VALUE_PRIORITY.LOW,
+        };
+        const mediumPriorityMsg: SyncMessage = {
+            action: "content",
+            id: "co_zmedium",
+            new: {},
+            priority: CO_VALUE_PRIORITY.MEDIUM,
+        };
+        const highPriorityMsg: SyncMessage = {
+            action: "content",
+            id: "co_zhigh",
+            new: {},
+            priority: CO_VALUE_PRIORITY.HIGH,
+        };
+
+        void queue.push(lowPriorityMsg);
+        void queue.push(mediumPriorityMsg);
+        void queue.push(highPriorityMsg);
+
+        expect(queue.pull()?.msg).toEqual(highPriorityMsg);
+        expect(queue.pull()?.msg).toEqual(mediumPriorityMsg);
+        expect(queue.pull()?.msg).toEqual(lowPriorityMsg);
+    });
+
+    test("should return undefined when pulling from empty queue", () => {
+        const { queue } = setup();
+        expect(queue.pull()).toBeUndefined();
+    });
+
+    test("should resolve promise when message is pulled", async () => {
+        const { queue } = setup();
+        const message: SyncMessage = {
+            action: "load",
+            id: "co_ztest-id",
+            header: false,
+            sessions: {},
+        };
+        const pushPromise = queue.push(message);
+
+        const pulledEntry = queue.pull();
+        pulledEntry?.resolve();
+
+        await expect(pushPromise).resolves.toBeUndefined();
+    });
+
+    test("should reject promise when message is rejected", async () => {
+        const { queue } = setup();
+        const message: SyncMessage = {
+            action: "load",
+            id: "co_ztest-id",
+            header: false,
+            sessions: {},
+        };
+        const pushPromise = queue.push(message);
+
+        const pulledEntry = queue.pull();
+        pulledEntry?.reject(new Error("Test error"));
+
+        await expect(pushPromise).rejects.toThrow("Test error");
+    });
+});

package/src/tests/coStream.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from "vitest";
+import { expect, test, describe } from "vitest";
 import { expectStream } from "../coValue.js";
 import { RawBinaryCoStream } from "../coValues/coStream.js";
 import { MAX_RECOMMENDED_TX_SIZE, WasmCrypto } from "../index.js";
@@ -244,3 +244,60 @@ test("When adding large transactions (bigger than MAX_RECOMMENDED_TX_SIZE), we s
         sessionEntry.lastSignature,
     );
 });
+
+describe("isBinaryStreamEnded", () => {
+    function setup() {
+        const node = new LocalNode(
+            ...randomAnonymousAccountAndSessionID(),
+            Crypto,
+        );
+
+        const coValue = node.createCoValue({
+            type: "costream",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: { type: "binary" },
+            ...Crypto.createdNowUnique(),
+        });
+
+        const content = coValue.getCurrentContent();
+
+        if (
+            content.type !== "costream" ||
+            content.headerMeta?.type !== "binary" ||
+            !(content instanceof RawBinaryCoStream)
+        ) {
+            throw new Error("Expected binary stream");
+        }
+
+        return content;
+    }
+
+    test("returns true when the last item is end", () => {
+        const stream = setup();
+
+        stream.startBinaryStream(
+            { mimeType: "text/plain", fileName: "test.txt" },
+            "trusting",
+        );
+        stream.endBinaryStream("trusting");
+
+        expect(stream.isBinaryStreamEnded()).toBe(true);
+    });
+
+    test("returns false if the stream isn't ended", () => {
+        const stream = setup();
+
+        stream.startBinaryStream(
+            { mimeType: "text/plain", fileName: "test.txt" },
+            "trusting",
+        );
+
+        expect(stream.isBinaryStreamEnded()).toBe(false);
+    });
+
+    test("returns false if the stream isn't started", () => {
+        const stream = setup();
+
+        expect(stream.isBinaryStreamEnded()).toBe(false);
+    });
+});

package/src/tests/priority.test.ts

@@ -0,0 +1,75 @@
+import { expect, test, describe } from "vitest";
+import { WasmCrypto } from "../index.js";
+import { LocalNode } from "../localNode.js";
+import { randomAnonymousAccountAndSessionID } from "./testUtils.js";
+import { getPriorityFromHeader, CO_VALUE_PRIORITY } from "../priority.js";
+
+const Crypto = await WasmCrypto.create();
+
+describe("getPriorityFromHeader", () => {
+    test("returns MEDIUM priority for boolean or undefined headers", () => {
+        expect(getPriorityFromHeader(true)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(false)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(undefined)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+
+    test("returns MEDIUM priority for costream type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const costream = node.createCoValue({
+            type: "costream",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+
+        expect(getPriorityFromHeader(costream.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+
+    test("returns LOW priority for binary costream type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const costream = node.createCoValue({
+            type: "costream",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: { type: "binary" },
+            ...Crypto.createdNowUnique(),
+        });
+
+        expect(getPriorityFromHeader(costream.header)).toEqual(CO_VALUE_PRIORITY.LOW);
+    });
+
+    test("returns HIGH priority for account type", async () => {
+        const node =new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+
+        const account = node.createAccount(node.crypto.newRandomAgentSecret());
+
+        expect(getPriorityFromHeader(account.core.header)).toEqual(CO_VALUE_PRIORITY.HIGH);
+    });
+
+    test("returns HIGH priority for group type", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        const group = node.createGroup();
+
+        expect(getPriorityFromHeader(group.core.header)).toEqual(CO_VALUE_PRIORITY.HIGH);
+    });
+
+    test("returns MEDIUM priority for other types", () => {
+        const node = new LocalNode(...randomAnonymousAccountAndSessionID(), Crypto);
+        
+        const comap = node.createCoValue({
+            type: "comap",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+
+        const colist = node.createCoValue({
+            type: "colist",
+            ruleset: { type: "unsafeAllowAll" },
+            meta: null,
+            ...Crypto.createdNowUnique(),
+        });
+
+        expect(getPriorityFromHeader(comap.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+        expect(getPriorityFromHeader(colist.header)).toEqual(CO_VALUE_PRIORITY.MEDIUM);
+    });
+});