cojson 0.8.12 → 0.8.17

package/src/tests/PeerKnownStates.test.ts

@@ -1,47 +1,51 @@
-import { PeerKnownStates } from '../PeerKnownStates.js';
-import { CoValueKnownState, emptyKnownState } from '../sync.js';
-import { RawCoID, SessionID } from '../ids.js';
-import { vi, describe, test, expect } from 'vitest';
+import { describe, expect, test, vi } from "vitest";
+import { PeerKnownStates } from "../PeerKnownStates.js";
+import { RawCoID, SessionID } from "../ids.js";
+import { CoValueKnownState, emptyKnownState } from "../sync.js";
 
-
-describe('PeerKnownStates', () => {
-  test('should set and get a known state', () => {
+describe("PeerKnownStates", () => {
+  test("should set and get a known state", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const knownState: CoValueKnownState = emptyKnownState(id);
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: knownState });
+    peerKnownStates.dispatch({ type: "SET", id, value: knownState });
 
     expect(peerKnownStates.get(id)).toEqual(knownState);
     expect(peerKnownStates.has(id)).toBe(true);
   });
 
-  test('should update header', () => {
+  test("should update header", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
 
-    peerKnownStates.dispatch({ type: 'UPDATE_HEADER', id, header: true });
+    peerKnownStates.dispatch({ type: "UPDATE_HEADER", id, header: true });
 
     const result = peerKnownStates.get(id);
     expect(result?.header).toBe(true);
   });
 
-  test('should update session counter', () => {
+  test("should update session counter", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const sessionId = 'session-1' as SessionID;
+    const id = "test-id" as RawCoID;
+    const sessionId = "session-1" as SessionID;
 
-    peerKnownStates.dispatch({ type: 'UPDATE_SESSION_COUNTER', id, sessionId, value: 5 });
+    peerKnownStates.dispatch({
+      type: "UPDATE_SESSION_COUNTER",
+      id,
+      sessionId,
+      value: 5,
+    });
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions[sessionId]).toBe(5);
   });
 
-  test('should combine with existing state', () => {
+  test("should combine with existing state", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const session1 = 'session-1' as SessionID;
-    const session2 = 'session-2' as SessionID;
+    const id = "test-id" as RawCoID;
+    const session1 = "session-1" as SessionID;
+    const session2 = "session-2" as SessionID;
     const initialState: CoValueKnownState = {
       ...emptyKnownState(id),
       sessions: { [session1]: 5 },
@@ -51,50 +55,50 @@ describe('PeerKnownStates', () => {
       sessions: { [session2]: 10 },
     };
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: initialState });
-    peerKnownStates.dispatch({ type: 'COMBINE_WITH', id, value: combineState });
+    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
+    peerKnownStates.dispatch({ type: "COMBINE_WITH", id, value: combineState });
 
     const result = peerKnownStates.get(id);
     expect(result?.sessions).toEqual({ [session1]: 5, [session2]: 10 });
   });
 
-  test('should set as empty', () => {
+  test("should set as empty", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
-    const sessionId = 'session-1' as SessionID;
+    const id = "test-id" as RawCoID;
+    const sessionId = "session-1" as SessionID;
     const initialState: CoValueKnownState = {
       ...emptyKnownState(id),
       sessions: { [sessionId]: 5 },
     };
 
-    peerKnownStates.dispatch({ type: 'SET', id, value: initialState });
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET", id, value: initialState });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     const result = peerKnownStates.get(id);
     expect(result).toEqual(emptyKnownState(id));
   });
 
-  test('should trigger listeners on dispatch', () => {
+  test("should trigger listeners on dispatch", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const listener = vi.fn();
 
     peerKnownStates.subscribe(listener);
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     expect(listener).toHaveBeenCalledWith(id, emptyKnownState(id));
   });
 
-  test('should unsubscribe listener', () => {
+  test("should unsubscribe listener", () => {
     const peerKnownStates = new PeerKnownStates();
-    const id = 'test-id' as RawCoID;
+    const id = "test-id" as RawCoID;
     const listener = vi.fn();
 
     const unsubscribe = peerKnownStates.subscribe(listener);
     unsubscribe();
 
-    peerKnownStates.dispatch({ type: 'SET_AS_EMPTY', id });
+    peerKnownStates.dispatch({ type: "SET_AS_EMPTY", id });
 
     expect(listener).not.toHaveBeenCalled();
   });
-});
+});

package/src/tests/PeerState.test.ts

@@ -1,81 +1,118 @@
-import { describe, test, expect, vi } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { PeerState } from "../PeerState.js";
-import { Peer, SyncMessage } from "../sync.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { Peer, SyncMessage } from "../sync.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 };
+  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 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 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 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 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 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();
+  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 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),
-        ];
+    const promises = [
+      peerState.pushOutgoingMessage(contentMessageLow),
+      peerState.pushOutgoingMessage(contentMessageMid),
+      peerState.pushOutgoingMessage(contentMessageHigh),
+      peerState.pushOutgoingMessage(loadMessage),
+    ];
 
-        await Promise.all(promises);
+    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); 
+    // 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);
-    });
+    // 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

@@ -1,111 +1,111 @@
-import { describe, test, expect } from "vitest";
+import { describe, expect, test } from "vitest";
 import { PriorityBasedMessageQueue } from "../PriorityBasedMessageQueue.js";
-import { SyncMessage } from "../sync.js";
 import { CO_VALUE_PRIORITY } from "../priority.js";
+import { SyncMessage } from "../sync.js";
 
 function setup() {
-    const queue = new PriorityBasedMessageQueue(CO_VALUE_PRIORITY.MEDIUM);
-    return { queue };
+  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 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 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 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,
-        };
+  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);
+    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);
-    });
+    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 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);
+  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();
+    const pulledEntry = queue.pull();
+    pulledEntry?.resolve();
 
-        await expect(pushPromise).resolves.toBeUndefined();
-    });
+    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);
+  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"));
+    const pulledEntry = queue.pull();
+    pulledEntry?.reject(new Error("Test error"));
 
-        await expect(pushPromise).rejects.toThrow("Test error");
-    });
+    await expect(pushPromise).rejects.toThrow("Test error");
+  });
 });