cojson 0.20.0 → 0.20.2

package/src/tests/coValueCore.loadFromStorage.test.ts

@@ -470,6 +470,114 @@ describe("CoValueCore.loadFromStorage", () => {
     });
   });
 
+  describe("when state is garbageCollected", () => {
+    test("should load from storage even if storage state is not unknown", () => {
+      const { state, node, header, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      // First, simulate that storage was previously accessed and marked available
+      state.markFoundInPeer("storage", state.loadingState);
+
+      // Then set the CoValue to garbageCollected state (simulating GC)
+      // This is what happens when a GC'd CoValueCore shell is created
+      state.setGarbageCollectedState({
+        id,
+        header: true,
+        sessions: {},
+      });
+
+      // Verify we're in garbageCollected state
+      expect(state.loadingState).toBe("garbageCollected");
+
+      // Now call loadFromStorage - it should proceed to load
+      state.loadFromStorage();
+
+      // Should have called storage.load because we need full content
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("should load from storage when garbageCollected and storage state is unknown", () => {
+      const { state, node, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({ load: loadSpy });
+      node.setStorage(storage);
+
+      // Set the CoValue to garbageCollected state
+      state.setGarbageCollectedState({
+        id,
+        header: true,
+        sessions: {},
+      });
+
+      expect(state.loadingState).toBe("garbageCollected");
+      expect(state.getLoadingStateForPeer("storage")).toBe("unknown");
+
+      state.loadFromStorage();
+
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("when state is onlyKnownState", () => {
+    test("should load from storage to get full content", () => {
+      const { state, node, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({
+        load: loadSpy,
+        loadKnownState: (id, callback) => {
+          // Simulate storage finding knownState
+          callback({
+            id,
+            header: true,
+            sessions: { session1: 5 },
+          });
+        },
+      });
+      node.setStorage(storage);
+
+      // First, call getKnownStateFromStorage to set onlyKnownState
+      state.getKnownStateFromStorage((knownState) => {
+        expect(knownState).toBeDefined();
+      });
+
+      // Verify we're in onlyKnownState
+      expect(state.loadingState).toBe("onlyKnownState");
+
+      // Now call loadFromStorage - it should proceed to load full content
+      state.loadFromStorage();
+
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("should load from storage when onlyKnownState and storage state is unknown", () => {
+      const { state, node, id } = setup();
+      const loadSpy = vi.fn();
+      const storage = createMockStorage({
+        load: loadSpy,
+        loadKnownState: (id, callback) => {
+          callback({
+            id,
+            header: true,
+            sessions: {},
+          });
+        },
+      });
+      node.setStorage(storage);
+
+      // Set onlyKnownState via getKnownStateFromStorage
+      state.getKnownStateFromStorage(() => {});
+
+      expect(state.loadingState).toBe("onlyKnownState");
+      expect(state.getLoadingStateForPeer("storage")).toBe("unknown");
+
+      state.loadFromStorage();
+
+      expect(loadSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
   describe("edge cases and integration", () => {
     test("should handle transition from unknown to pending to available", async () => {
       const { state, node, header } = setup();

package/src/tests/knownState.lazyLoading.test.ts

@@ -222,4 +222,56 @@ describe("CoValueCore.getKnownStateFromStorage", () => {
 
     expect(doneSpy).toHaveBeenCalledWith(undefined);
   });
+
+  test("sets onlyKnownState and caches lastKnownState when storage returns data", () => {
+    const { node, coValue, id } = setup();
+    const storageKnownState = {
+      id,
+      header: true,
+      sessions: { session1: 5 },
+    };
+    const loadKnownStateSpy = vi.fn((id, callback) => {
+      callback(storageKnownState);
+    });
+    const storage = createMockStorage({ loadKnownState: loadKnownStateSpy });
+    node.setStorage(storage);
+
+    // Initially unknown
+    expect(coValue.loadingState).toBe("unknown");
+
+    const doneSpy = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy);
+
+    // After storage returns data, should be onlyKnownState
+    expect(coValue.loadingState).toBe("onlyKnownState");
+
+    // knownState() should return the cached lastKnownState
+    expect(coValue.knownState()).toEqual(storageKnownState);
+  });
+
+  test("returns cached lastKnownState on subsequent calls without hitting storage", () => {
+    const { node, coValue, id } = setup();
+    const storageKnownState = {
+      id,
+      header: true,
+      sessions: { session1: 5 },
+    };
+    const loadKnownStateSpy = vi.fn((id, callback) => {
+      callback(storageKnownState);
+    });
+    const storage = createMockStorage({ loadKnownState: loadKnownStateSpy });
+    node.setStorage(storage);
+
+    // First call - hits storage
+    const doneSpy1 = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy1);
+    expect(loadKnownStateSpy).toHaveBeenCalledTimes(1);
+    expect(doneSpy1).toHaveBeenCalledWith(storageKnownState);
+
+    // Second call - should use cached lastKnownState, not hit storage
+    const doneSpy2 = vi.fn();
+    coValue.getKnownStateFromStorage(doneSpy2);
+    expect(loadKnownStateSpy).toHaveBeenCalledTimes(1); // Still 1, not 2
+    expect(doneSpy2).toHaveBeenCalledWith(storageKnownState);
+  });
 });