cojson 0.19.21 → 0.20.0

package/src/tests/GarbageCollector.test.ts

@@ -1,7 +1,13 @@
 import { assert, beforeEach, describe, expect, test, vi } from "vitest";
 
 import { setGarbageCollectorMaxAge } from "../config";
-import { TEST_NODE_CONFIG, setupTestAccount, setupTestNode } from "./testUtils";
+import {
+  blockMessageTypeOnOutgoingPeer,
+  TEST_NODE_CONFIG,
+  setupTestAccount,
+  setupTestNode,
+} from "./testUtils";
+import { createSyncStorage } from "./testStorage.js";
 
 // We want to simulate a real world communication that happens asynchronously
 TEST_NODE_CONFIG.withAsyncPeers = true;
@@ -10,6 +16,8 @@ beforeEach(() => {
   // We want to test what happens when the garbage collector kicks in and removes a coValue
   // We set the max age to -1 to make it remove everything
   setGarbageCollectorMaxAge(-1);
+
+  setupTestNode({ isSyncServer: true });
 });
 
 describe("garbage collector", () => {
@@ -19,13 +27,14 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
     const map = group.createMap();
     map.set("hello", "world", "trusting");
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
@@ -40,6 +49,7 @@ describe("garbage collector", () => {
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
@@ -51,7 +61,7 @@ describe("garbage collector", () => {
       // This listener keeps the coValue alive
     });
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
@@ -66,45 +76,137 @@ describe("garbage collector", () => {
     expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
   });
 
-  test("coValues are not garbage collected if they are a group or account", async () => {
-    const client = await setupTestAccount();
+  test("coValues are not garbage collected if they are not synced with server peers", async () => {
+    const client = setupTestNode();
 
     client.addStorage({
       ourName: "client",
     });
-    client.node.enableGarbageCollector({
-      garbageCollectGroups: true,
-    });
+    client.node.enableGarbageCollector();
+    const { peer: serverPeer } = client.connectToSyncServer();
+    // Block sync with server
+    const blocker = blockMessageTypeOnOutgoingPeer(serverPeer, "content", {});
 
     const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
 
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     client.node.garbageCollector?.collect();
 
-    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(true);
+
+    // Resume sync with server
+    blocker.sendBlockedMessages();
+    blocker.unblock();
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // The coValue should now be collected
+    client.node.garbageCollector?.collect();
+
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+  });
+
+  test("coValues are garbage collected if there are no server peers", async () => {
+    const client = setupTestNode();
+
+    client.addStorage({
+      ourName: "client",
+    });
+    client.node.enableGarbageCollector();
+    // Client is not connected to the sync server
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    client.node.garbageCollector?.collect();
+
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+  });
+
+  test("account coValues are not garbage collected if they have dependencies", async () => {
+    const client = await setupTestAccount({
+      // Add storage before creating the account so it's persisted
+      storage: createSyncStorage({
+        nodeName: "client",
+        storageName: "storage",
+      }),
+    });
+    // The account is created along with its profile, and the group that owns the profile
+    const profile = client.node.expectProfileLoaded(client.accountID);
+    const profileId = profile.id;
+    const profileOwnerId = profile.group.id;
+
+    client.connectToSyncServer();
+    client.node.enableGarbageCollector();
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // First collect removes the profile
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(profileId).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(profileOwnerId).isAvailable()).toBe(true);
+    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+
+    // Second collect removes the profile owner
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(profileOwnerId).isAvailable()).toBe(false);
+    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+
+    // Third collect removes the account
+    client.node.garbageCollector?.collect();
     expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(false);
   });
 
-  test("group or account coValues are garbage collected if garbageCollectGroups is true", async () => {
-    const client = await setupTestAccount();
+  test("group coValues are garbage collected if they have no dependencies", async () => {
+    const client = setupTestNode();
 
     client.addStorage({
       ourName: "client",
     });
+    client.connectToSyncServer();
     client.node.enableGarbageCollector();
 
     const group = client.node.createGroup();
 
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await client.node.syncManager.waitForAllCoValuesSync();
 
     client.node.garbageCollector?.collect();
 
+    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
+  });
+
+  test("group coValues are not garbage collected if they have dependencies", async () => {
+    const client = setupTestNode();
+
+    client.addStorage({
+      ourName: "client",
+    });
+    client.node.enableGarbageCollector();
+
+    const group = client.node.createGroup();
+    const map = group.createMap();
+    map.set("hello", "world", "trusting");
+
+    await client.node.syncManager.waitForAllCoValuesSync();
+
+    // First collect removes the map
+    client.node.garbageCollector?.collect();
     expect(client.node.getCoValue(group.id).isAvailable()).toBe(true);
-    expect(client.node.getCoValue(client.accountID).isAvailable()).toBe(true);
+    expect(client.node.getCoValue(map.id).isAvailable()).toBe(false);
+
+    // Second collect removes the group
+    client.node.garbageCollector?.collect();
+    expect(client.node.getCoValue(group.id).isAvailable()).toBe(false);
   });
 
   test("coValues are not garbage collected if the maxAge is not reached", async () => {
+    vi.useFakeTimers();
+
     setGarbageCollectorMaxAge(1000);
 
     const client = setupTestNode();
@@ -118,30 +220,25 @@ describe("garbage collector", () => {
 
     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);
   });
 });