cojson 0.19.22 → 0.20.1

package/src/tests/DeletedCoValuesEraserScheduler.test.ts

@@ -0,0 +1,185 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { logger } from "../logger.js";
+import { DeletedCoValuesEraserScheduler } from "../storage/DeletedCoValuesEraserScheduler.js";
+
+describe("DeletedCoValuesEraserScheduler", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.clearAllTimers();
+    vi.useRealTimers();
+  });
+
+  test("scheduleStartupDrain runs once after startupDelayMs (when idle)", async () => {
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        return { hasMore: false };
+      },
+      opts: { throttleMs: 50, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.scheduleStartupDrain();
+
+    expect(runs).toBe(0);
+    await vi.advanceTimersByTimeAsync(10);
+    expect(runs).toBe(1);
+    scheduler.dispose();
+  });
+
+  test("onEnqueueDeletedCoValue is throttled (multiple enqueues -> one run)", async () => {
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        return { hasMore: false };
+      },
+      opts: { throttleMs: 30, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue();
+    scheduler.onEnqueueDeletedCoValue();
+    scheduler.onEnqueueDeletedCoValue();
+
+    expect(runs).toBe(0);
+    await vi.advanceTimersByTimeAsync(29);
+    expect(runs).toBe(0);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(runs).toBe(1);
+
+    // Ensure no second run was scheduled by repeated enqueues in the same throttle window.
+    await vi.advanceTimersByTimeAsync(100);
+    expect(runs).toBe(1);
+
+    scheduler.dispose();
+  });
+
+  test("schedules follow-up phases while run reports hasMore=true", async () => {
+    let remaining = 3;
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        remaining -= 1;
+        return { hasMore: remaining > 0 };
+      },
+      opts: { throttleMs: 10, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue();
+
+    await vi.runAllTimersAsync();
+    expect(runs).toBe(3);
+    scheduler.dispose();
+  });
+
+  test("never runs run concurrently (re-entrancy guard via internal state machine)", async () => {
+    let concurrent = 0;
+    let maxConcurrent = 0;
+    let remaining = 2;
+
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        concurrent += 1;
+        maxConcurrent = Math.max(maxConcurrent, concurrent);
+
+        await new Promise<void>((resolve) => setTimeout(resolve, 30));
+        remaining -= 1;
+
+        concurrent -= 1;
+        return { hasMore: remaining > 0 };
+      },
+      opts: { throttleMs: 10, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue();
+    await vi.advanceTimersByTimeAsync(10); // start first run
+
+    // Even if we spam enqueues while active, they should be ignored.
+    scheduler.onEnqueueDeletedCoValue();
+    scheduler.onEnqueueDeletedCoValue();
+
+    await vi.runAllTimersAsync();
+    expect(remaining).toBe(0);
+    expect(maxConcurrent).toBe(1);
+
+    scheduler.dispose();
+  });
+
+  test("ignores enqueues while not idle, but schedules again once idle", async () => {
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        return { hasMore: false };
+      },
+      opts: { throttleMs: 30, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue(); // schedules first run
+    await vi.advanceTimersByTimeAsync(5);
+    scheduler.onEnqueueDeletedCoValue(); // should be ignored (not idle)
+
+    await vi.advanceTimersByTimeAsync(25);
+    expect(runs).toBe(1);
+
+    // Now idle again; next enqueue should schedule another run.
+    scheduler.onEnqueueDeletedCoValue();
+    await vi.advanceTimersByTimeAsync(30);
+    expect(runs).toBe(2);
+
+    scheduler.dispose();
+  });
+
+  test("dispose cancels any scheduled run", async () => {
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        return { hasMore: false };
+      },
+      opts: { throttleMs: 30, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue();
+    scheduler.dispose();
+
+    await vi.advanceTimersByTimeAsync(60);
+    expect(runs).toBe(0);
+  });
+
+  test("recovers when run throws (logs error and returns to idle so it can run again)", async () => {
+    const err = new Error("boom");
+    const errorSpy = vi.spyOn(logger, "error").mockImplementation(() => {});
+
+    let runs = 0;
+    const scheduler = new DeletedCoValuesEraserScheduler({
+      run: async () => {
+        runs += 1;
+        if (runs === 1) throw err;
+        return { hasMore: false };
+      },
+      opts: { throttleMs: 10, startupDelayMs: 10, followUpDelayMs: 10 },
+    });
+
+    scheduler.onEnqueueDeletedCoValue();
+    await vi.advanceTimersByTimeAsync(10);
+    expect(runs).toBe(1);
+
+    expect(errorSpy).toHaveBeenCalledWith(
+      "Error running deleted co values eraser scheduler",
+      expect.objectContaining({ err }),
+    );
+
+    // If the scheduler didn't reset back to idle after the error, this enqueue would be ignored.
+    scheduler.onEnqueueDeletedCoValue();
+    await vi.advanceTimersByTimeAsync(10);
+    expect(runs).toBe(2);
+
+    scheduler.dispose();
+    errorSpy.mockRestore();
+  });
+});

package/src/tests/GarbageCollector.test.ts

@@ -205,6 +205,8 @@ describe("garbage collector", () => {
   });
 
   test("coValues are not garbage collected if the maxAge is not reached", async () => {
+    vi.useFakeTimers();
+
     setGarbageCollectorMaxAge(1000);
 
     const client = setupTestNode();
@@ -212,37 +214,31 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
-    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const garbageCollector = client.node.garbageCollector;
 
     assert(garbageCollector);
 
-    const getCurrentTime = vi.spyOn(garbageCollector, "getCurrentTime");
-
-    getCurrentTime.mockReturnValue(1);
+    await vi.advanceTimersByTimeAsync(100);
 
     const group = client.node.createGroup();
     const map1 = group.createMap();
     const map2 = group.createMap();
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await vi.advanceTimersByTimeAsync(800);
 
+    // Access map1 again, to prevent it from being garbage collected
     map1.set("hello", "world", "trusting");
 
-    getCurrentTime.mockReturnValue(2000);
-
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await vi.advanceTimersByTimeAsync(300);
 
     garbageCollector.collect();
 
     const coValue = client.node.getCoValue(map1.id);
-
     expect(coValue.isAvailable()).toBe(true);
 
     const coValue2 = client.node.getCoValue(map2.id);
-
     expect(coValue2.isAvailable()).toBe(false);
   });
 });

package/src/tests/LinkedList.test.ts

@@ -76,6 +76,117 @@ describe("LinkedList", () => {
     });
   });
 
+  describe("remove", () => {
+    it("should remove the only element in the list", () => {
+      const node = list.push(1);
+      list.remove(node);
+
+      expect(list.length).toBe(0);
+      expect(list.head).toBeUndefined();
+      expect(list.tail).toBeUndefined();
+      expect(node.prev).toBeUndefined();
+      expect(node.next).toBeUndefined();
+    });
+
+    it("should remove the head element", () => {
+      const node1 = list.push(1);
+      const node2 = list.push(2);
+      const node3 = list.push(3);
+
+      list.remove(node1);
+
+      expect(list.length).toBe(2);
+      expect(list.head).toBe(node2);
+      expect(list.tail).toBe(node3);
+      expect(node2.prev).toBeUndefined();
+      expect(node1.prev).toBeUndefined();
+      expect(node1.next).toBeUndefined();
+    });
+
+    it("should remove the tail element", () => {
+      const node1 = list.push(1);
+      const node2 = list.push(2);
+      const node3 = list.push(3);
+
+      list.remove(node3);
+
+      expect(list.length).toBe(2);
+      expect(list.head).toBe(node1);
+      expect(list.tail).toBe(node2);
+      expect(node2.next).toBeUndefined();
+      expect(node3.prev).toBeUndefined();
+      expect(node3.next).toBeUndefined();
+    });
+
+    it("should remove a middle element", () => {
+      const node1 = list.push(1);
+      const node2 = list.push(2);
+      const node3 = list.push(3);
+
+      list.remove(node2);
+
+      expect(list.length).toBe(2);
+      expect(list.head).toBe(node1);
+      expect(list.tail).toBe(node3);
+      expect(node1.next).toBe(node3);
+      expect(node3.prev).toBe(node1);
+      expect(node2.prev).toBeUndefined();
+      expect(node2.next).toBeUndefined();
+    });
+
+    it("should maintain correct state after multiple removes", () => {
+      const node1 = list.push(1);
+      const node2 = list.push(2);
+      const node3 = list.push(3);
+      const node4 = list.push(4);
+
+      // Remove middle
+      list.remove(node2);
+      expect(list.length).toBe(3);
+      expect(node1.next).toBe(node3);
+      expect(node3.prev).toBe(node1);
+
+      // Remove head
+      list.remove(node1);
+      expect(list.length).toBe(2);
+      expect(list.head).toBe(node3);
+
+      // Remove tail
+      list.remove(node4);
+      expect(list.length).toBe(1);
+      expect(list.head).toBe(node3);
+      expect(list.tail).toBe(node3);
+
+      // Remove last
+      list.remove(node3);
+      expect(list.length).toBe(0);
+      expect(list.head).toBeUndefined();
+      expect(list.tail).toBeUndefined();
+    });
+
+    it("should allow shift after remove", () => {
+      const node1 = list.push(1);
+      list.push(2);
+      list.push(3);
+
+      list.remove(node1);
+
+      expect(list.shift()).toBe(2);
+      expect(list.shift()).toBe(3);
+      expect(list.length).toBe(0);
+    });
+
+    it("should allow push after remove", () => {
+      const node1 = list.push(1);
+      list.remove(node1);
+
+      list.push(2);
+      expect(list.length).toBe(1);
+      expect(list.head?.value).toBe(2);
+      expect(list.tail?.value).toBe(2);
+    });
+  });
+
   describe("edge cases", () => {
     it("should handle push after all elements have been shifted", () => {
       list.push(1);