@multiplatform.one/frappe 6.0.0

package/dist/cjs/sync/realtime.spec.cjs

@@ -0,0 +1,499 @@
+var import_vitest = require("vitest");
+var import_realtime = require("./realtime.cjs");
+var import_types = require("./types.cjs");
+(0, import_vitest.describe)("RealtimeHandler", () => {
+  let realtimeHandler;
+  let mockDb;
+  let mockRealtime;
+  let mockNormalizedCache;
+  let mockSubscriptionManager;
+  let mockRehydrationManager;
+  let eventHandlers;
+  (0, import_vitest.beforeEach)(() => {
+    import_vitest.vi.useFakeTimers();
+    eventHandlers = {};
+    mockDb = {
+      getDoc: import_vitest.vi.fn().mockResolvedValue({
+        name: "test-doc",
+        doctype: "TestDoc"
+      })
+    };
+    mockRealtime = {
+      on: import_vitest.vi.fn().mockImplementation((event, handler) => {
+        eventHandlers[event] = handler;
+      }),
+      isHealthy: import_vitest.vi.fn().mockReturnValue(true),
+      disconnect: import_vitest.vi.fn()
+    };
+    mockNormalizedCache = {
+      upsert: import_vitest.vi.fn(),
+      remove: import_vitest.vi.fn()
+    };
+    mockSubscriptionManager = {
+      updateSubscriptionMembership: import_vitest.vi.fn().mockReturnValue([]),
+      removeFromAllSubscriptions: import_vitest.vi.fn().mockReturnValue([])
+    };
+    mockRehydrationManager = {
+      scheduleRehydration: import_vitest.vi.fn()
+    };
+    import_vitest.vi.spyOn(console, "debug").mockImplementation(() => {});
+    import_vitest.vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+  (0, import_vitest.afterEach)(() => {
+    import_vitest.vi.restoreAllMocks();
+    import_vitest.vi.useRealTimers();
+  });
+  (0, import_vitest.describe)("constructor and initialization", () => {
+    (0, import_vitest.it)("should initialize with default connection config", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledWith("doc_changed", import_vitest.expect.any(Function));
+      (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledWith("doc_deleted", import_vitest.expect.any(Function));
+      (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledWith("perm_epoch_bump", import_vitest.expect.any(Function));
+      (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledWith("connected", import_vitest.expect.any(Function));
+      (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledWith("disconnect", import_vitest.expect.any(Function));
+    });
+    (0, import_vitest.it)("should initialize with custom connection config", () => {
+      const options = {
+        connectionConfig: {
+          reconnectBaseDelay: 2e3,
+          reconnectMaxDelay: 6e4,
+          reconnectJitter: 0.5,
+          exponentialBackoff: false
+        }
+      };
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, options);
+      (0, import_vitest.expect)(realtimeHandler).toBeDefined();
+    });
+    (0, import_vitest.it)("should handle no realtime module gracefully", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, void 0, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(realtimeHandler).toBeDefined();
+      (0, import_vitest.expect)(mockRealtime.on).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle no rehydration manager gracefully", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, void 0, {});
+      (0, import_vitest.expect)(realtimeHandler).toBeDefined();
+    });
+  });
+  (0, import_vitest.describe)("realtime event handlers", () => {
+    (0, import_vitest.beforeEach)(() => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.describe)("doc_changed event", () => {
+      (0, import_vitest.it)("should handle doc_changed event successfully", async () => {
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        const mockDoc = {
+          name: "test-doc",
+          doctype: "TestDoc",
+          title: "Test Document"
+        };
+        mockDb.getDoc.mockResolvedValue(mockDoc);
+        await eventHandlers.doc_changed(payload);
+        (0, import_vitest.expect)(mockDb.getDoc).toHaveBeenCalledWith("TestDoc", "test-doc");
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).toHaveBeenCalledWith(mockDoc);
+        (0, import_vitest.expect)(mockSubscriptionManager.updateSubscriptionMembership).toHaveBeenCalledWith(mockDoc);
+      });
+      (0, import_vitest.it)("should schedule rehydration for subscriptions needing it", async () => {
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        const mockDoc = {
+          name: "test-doc",
+          doctype: "TestDoc"
+        };
+        const mockSubscriptions = [{
+          id: "sub1",
+          query: {
+            doctype: "TestDoc"
+          },
+          docIds: []
+        }, {
+          id: "sub2",
+          query: {
+            doctype: "TestDoc"
+          },
+          docIds: []
+        }];
+        mockDb.getDoc.mockResolvedValue(mockDoc);
+        mockSubscriptionManager.updateSubscriptionMembership.mockReturnValue(mockSubscriptions);
+        await eventHandlers.doc_changed(payload);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledTimes(2);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(mockSubscriptions[0], import_types.RehydrationReason.RemoteCreate);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(mockSubscriptions[1], import_types.RehydrationReason.RemoteCreate);
+      });
+      (0, import_vitest.it)("should handle fetch errors gracefully", async () => {
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        mockDb.getDoc.mockRejectedValue(new Error("Permission denied"));
+        await eventHandlers.doc_changed(payload);
+        (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Failed to fetch document TestDoc/test-doc"), import_vitest.expect.any(Error));
+        (0, import_vitest.expect)(mockNormalizedCache.upsert).not.toHaveBeenCalled();
+      });
+      (0, import_vitest.it)("should call onRealtimeEvent callback if provided", async () => {
+        const onRealtimeEvent = import_vitest.vi.fn();
+        realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+          onRealtimeEvent
+        });
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        await eventHandlers.doc_changed(payload);
+        (0, import_vitest.expect)(onRealtimeEvent).toHaveBeenCalledWith({
+          type: import_types.RealtimeEventType.DocChanged,
+          payload
+        });
+      });
+    });
+    (0, import_vitest.describe)("doc_deleted event", () => {
+      (0, import_vitest.it)("should handle doc_deleted event successfully", async () => {
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        const affectedSubscriptions = [{
+          id: "sub1",
+          docIds: []
+        }, {
+          id: "sub2",
+          docIds: []
+        }];
+        mockSubscriptionManager.removeFromAllSubscriptions.mockReturnValue(affectedSubscriptions);
+        await eventHandlers.doc_deleted(payload);
+        (0, import_vitest.expect)(mockNormalizedCache.remove).toHaveBeenCalledWith({
+          doctype: "TestDoc",
+          name: "test-doc"
+        });
+        (0, import_vitest.expect)(mockSubscriptionManager.removeFromAllSubscriptions).toHaveBeenCalledWith("TestDoc", "test-doc");
+      });
+      (0, import_vitest.it)("should schedule rehydration for affected subscriptions", async () => {
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        const affectedSubscriptions = [{
+          id: "sub1",
+          docIds: []
+        }, {
+          id: "sub2",
+          docIds: []
+        }];
+        mockSubscriptionManager.removeFromAllSubscriptions.mockReturnValue(affectedSubscriptions);
+        await eventHandlers.doc_deleted(payload);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledTimes(2);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(affectedSubscriptions[0], import_types.RehydrationReason.Delete);
+        (0, import_vitest.expect)(mockRehydrationManager.scheduleRehydration).toHaveBeenCalledWith(affectedSubscriptions[1], import_types.RehydrationReason.Delete);
+      });
+      (0, import_vitest.it)("should call onRealtimeEvent callback if provided", async () => {
+        const onRealtimeEvent = import_vitest.vi.fn();
+        realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+          onRealtimeEvent
+        });
+        const payload = {
+          doctype: "TestDoc",
+          name: "test-doc"
+        };
+        await eventHandlers.doc_deleted(payload);
+        (0, import_vitest.expect)(onRealtimeEvent).toHaveBeenCalledWith({
+          type: import_types.RealtimeEventType.DocDeleted,
+          payload
+        });
+      });
+    });
+    (0, import_vitest.describe)("perm_epoch_bump event", () => {
+      (0, import_vitest.it)("should handle perm_epoch_bump event", () => {
+        const onResetCache = import_vitest.vi.fn();
+        realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+          onResetCache
+        });
+        eventHandlers.perm_epoch_bump();
+        (0, import_vitest.expect)(onResetCache).toHaveBeenCalled();
+      });
+      (0, import_vitest.it)("should call onRealtimeEvent callback if provided", () => {
+        const onRealtimeEvent = import_vitest.vi.fn();
+        realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+          onRealtimeEvent
+        });
+        eventHandlers.perm_epoch_bump();
+        (0, import_vitest.expect)(onRealtimeEvent).toHaveBeenCalledWith({
+          type: import_types.RealtimeEventType.PermEpochBump
+        });
+      });
+    });
+  });
+  (0, import_vitest.describe)("connection management", () => {
+    (0, import_vitest.beforeEach)(() => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.describe)("connected event", () => {
+      (0, import_vitest.it)("should handle successful connection", () => {
+        const onRealtimeEvent = import_vitest.vi.fn();
+        const onBackfillAll = import_vitest.vi.fn();
+        realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+          onRealtimeEvent,
+          onBackfillAll
+        });
+        eventHandlers.connected();
+        (0, import_vitest.expect)(onRealtimeEvent).toHaveBeenCalledWith({
+          type: import_types.RealtimeEventType.Connected
+        });
+        (0, import_vitest.expect)(onBackfillAll).toHaveBeenCalled();
+        (0, import_vitest.expect)(console.debug).toHaveBeenCalledWith("[RealtimeHandler] Connected to realtime server");
+      });
+      (0, import_vitest.it)("should reset reconnection attempts on successful connection", () => {
+        eventHandlers.disconnect();
+        import_vitest.vi.advanceTimersByTime(1e3);
+        eventHandlers.connected();
+        import_vitest.vi.advanceTimersByTime(5e3);
+        (0, import_vitest.expect)(mockRealtime.on).toHaveBeenCalledTimes(5);
+      });
+    });
+    (0, import_vitest.describe)("disconnect event", () => {
+      (0, import_vitest.it)("should handle disconnection", () => {
+        eventHandlers.disconnect();
+        (0, import_vitest.expect)(console.debug).toHaveBeenCalledWith("[RealtimeHandler] Disconnected from realtime server");
+      });
+      (0, import_vitest.it)("should schedule reconnection if previously connected", () => {
+        eventHandlers.connected();
+        eventHandlers.disconnect();
+        (0, import_vitest.expect)(console.debug).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Scheduling reconnection attempt"));
+      });
+      (0, import_vitest.it)("should not schedule reconnection if never connected", () => {
+        eventHandlers.disconnect();
+        import_vitest.vi.advanceTimersByTime(5e3);
+        (0, import_vitest.expect)(console.debug).not.toHaveBeenCalledWith(import_vitest.expect.stringContaining("Scheduling reconnection"));
+      });
+    });
+  });
+  (0, import_vitest.describe)("reconnection logic", () => {
+    (0, import_vitest.beforeEach)(() => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+        connectionConfig: {
+          reconnectBaseDelay: 1e3,
+          reconnectMaxDelay: 8e3,
+          reconnectJitter: 0.1,
+          exponentialBackoff: true
+        }
+      });
+    });
+    (0, import_vitest.it)("should use exponential backoff for reconnection", () => {
+      eventHandlers.connected();
+      eventHandlers.disconnect();
+      (0, import_vitest.expect)(console.debug).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Scheduling reconnection attempt 1 in"));
+      import_vitest.vi.advanceTimersByTime(1200);
+      eventHandlers.disconnect();
+      (0, import_vitest.expect)(console.debug).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Scheduling reconnection attempt 2 in"));
+    });
+    (0, import_vitest.it)("should cap reconnection delay at max delay", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+        connectionConfig: {
+          reconnectBaseDelay: 1e3,
+          reconnectMaxDelay: 2e3,
+          reconnectJitter: 0,
+          exponentialBackoff: true
+        }
+      });
+      eventHandlers.connected();
+      for (let i = 0; i < 5; i++) {
+        eventHandlers.disconnect();
+        import_vitest.vi.advanceTimersByTime(3e3);
+      }
+      eventHandlers.disconnect();
+      const lastCall = console.debug.mock.calls.filter(call => call[0].includes("Scheduling reconnection")).pop();
+      if (lastCall) {
+        const delayMatch = lastCall[0].match(/in (\d+)ms/);
+        if (delayMatch) {
+          const delay = Number.parseInt(delayMatch[1]);
+          (0, import_vitest.expect)(delay).toBeLessThanOrEqual(2e3);
+        }
+      }
+    });
+    (0, import_vitest.it)("should apply jitter to reconnection delays", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+        connectionConfig: {
+          reconnectBaseDelay: 1e3,
+          reconnectMaxDelay: 8e3,
+          reconnectJitter: 0.5,
+          // High jitter for testing
+          exponentialBackoff: false
+        }
+      });
+      eventHandlers.connected();
+      const delays = [];
+      for (let i = 0; i < 3; i++) {
+        eventHandlers.disconnect();
+        const lastCall = console.debug.mock.calls.filter(call => call[0].includes("Scheduling reconnection")).pop();
+        if (lastCall) {
+          const delayMatch = lastCall[0].match(/in (\d+)ms/);
+          if (delayMatch) {
+            delays.push(Number.parseInt(delayMatch[1]));
+          }
+        }
+        import_vitest.vi.advanceTimersByTime(2e3);
+      }
+      const uniqueDelays = new Set(delays);
+      (0, import_vitest.expect)(uniqueDelays.size).toBeGreaterThan(1);
+    });
+    (0, import_vitest.it)("should disable exponential backoff when configured", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {
+        connectionConfig: {
+          reconnectBaseDelay: 1e3,
+          reconnectMaxDelay: 8e3,
+          reconnectJitter: 0,
+          exponentialBackoff: false
+        }
+      });
+      eventHandlers.connected();
+      const delays = [];
+      for (let i = 0; i < 3; i++) {
+        eventHandlers.disconnect();
+        const lastCall = console.debug.mock.calls.filter(call => call[0].includes("Scheduling reconnection")).pop();
+        if (lastCall) {
+          const delayMatch = lastCall[0].match(/in (\d+)ms/);
+          if (delayMatch) {
+            delays.push(Number.parseInt(delayMatch[1]));
+          }
+        }
+        import_vitest.vi.advanceTimersByTime(1500);
+      }
+      delays.forEach(delay => {
+        (0, import_vitest.expect)(delay).toBe(1e3);
+      });
+    });
+  });
+  (0, import_vitest.describe)("isRealtimeHealthy", () => {
+    (0, import_vitest.it)("should return true when realtime is healthy", () => {
+      mockRealtime.isHealthy.mockReturnValue(true);
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(realtimeHandler.isRealtimeHealthy()).toBe(true);
+    });
+    (0, import_vitest.it)("should return false when realtime is unhealthy", () => {
+      mockRealtime.isHealthy.mockReturnValue(false);
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(realtimeHandler.isRealtimeHealthy()).toBe(false);
+    });
+    (0, import_vitest.it)("should return false when no realtime module", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, void 0, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(realtimeHandler.isRealtimeHealthy()).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("dispose", () => {
+    (0, import_vitest.beforeEach)(() => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.it)("should clear timers and disconnect", () => {
+      eventHandlers.connected();
+      eventHandlers.disconnect();
+      realtimeHandler.dispose();
+      (0, import_vitest.expect)(mockRealtime.disconnect).toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle dispose without active timers", () => {
+      (0, import_vitest.expect)(() => realtimeHandler.dispose()).not.toThrow();
+      (0, import_vitest.expect)(mockRealtime.disconnect).toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should handle dispose with no realtime module", () => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, void 0, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+      (0, import_vitest.expect)(() => realtimeHandler.dispose()).not.toThrow();
+    });
+  });
+  (0, import_vitest.describe)("error handling and edge cases", () => {
+    (0, import_vitest.beforeEach)(() => {
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, {});
+    });
+    (0, import_vitest.it)("should handle malformed doc_changed payloads", async () => {
+      await (0, import_vitest.expect)(eventHandlers.doc_changed(null)).resolves.not.toThrow();
+      await (0, import_vitest.expect)(eventHandlers.doc_changed({})).resolves.not.toThrow();
+      await (0, import_vitest.expect)(eventHandlers.doc_changed({
+        doctype: "Test"
+      })).resolves.not.toThrow();
+    });
+    (0, import_vitest.it)("should handle malformed doc_deleted payloads", async () => {
+      await (0, import_vitest.expect)(eventHandlers.doc_deleted(null)).resolves.not.toThrow();
+      await (0, import_vitest.expect)(eventHandlers.doc_deleted({})).resolves.not.toThrow();
+      await (0, import_vitest.expect)(eventHandlers.doc_deleted({
+        doctype: "Test"
+      })).resolves.not.toThrow();
+    });
+    (0, import_vitest.it)("should handle database errors during doc_changed", async () => {
+      mockDb.getDoc.mockRejectedValue(new Error("Database error"));
+      await eventHandlers.doc_changed({
+        doctype: "Test",
+        name: "test"
+      });
+      (0, import_vitest.expect)(console.warn).toHaveBeenCalledWith(import_vitest.expect.stringContaining("Failed to fetch document"), import_vitest.expect.any(Error));
+    });
+    (0, import_vitest.it)("should handle cache errors gracefully", async () => {
+      const payload = {
+        doctype: "TestDoc",
+        name: "test-doc"
+      };
+      const mockDoc = {
+        name: "test-doc",
+        doctype: "TestDoc"
+      };
+      mockDb.getDoc.mockResolvedValue(mockDoc);
+      mockNormalizedCache.upsert.mockImplementation(() => {
+        throw new Error("Cache error");
+      });
+      await (0, import_vitest.expect)(eventHandlers.doc_changed(payload)).resolves.not.toThrow();
+    });
+    (0, import_vitest.it)("should handle subscription manager errors gracefully", async () => {
+      const payload = {
+        doctype: "TestDoc",
+        name: "test-doc"
+      };
+      const mockDoc = {
+        name: "test-doc",
+        doctype: "TestDoc"
+      };
+      mockDb.getDoc.mockResolvedValue(mockDoc);
+      mockSubscriptionManager.updateSubscriptionMembership.mockImplementation(() => {
+        throw new Error("Subscription error");
+      });
+      await (0, import_vitest.expect)(eventHandlers.doc_changed(payload)).resolves.not.toThrow();
+    });
+    (0, import_vitest.it)("should handle rehydration manager errors gracefully", async () => {
+      const payload = {
+        doctype: "TestDoc",
+        name: "test-doc"
+      };
+      const affectedSubscriptions = [{
+        id: "sub1",
+        docIds: []
+      }];
+      mockSubscriptionManager.removeFromAllSubscriptions.mockReturnValue(affectedSubscriptions);
+      mockRehydrationManager.scheduleRehydration.mockImplementation(() => {
+        throw new Error("Rehydration error");
+      });
+      await (0, import_vitest.expect)(eventHandlers.doc_deleted(payload)).resolves.not.toThrow();
+    });
+  });
+  (0, import_vitest.describe)("callback integration", () => {
+    (0, import_vitest.it)("should integrate all callbacks properly", async () => {
+      const callbacks = {
+        onRealtimeEvent: import_vitest.vi.fn(),
+        onResetCache: import_vitest.vi.fn(),
+        onBackfillAll: import_vitest.vi.fn()
+      };
+      realtimeHandler = new import_realtime.RealtimeHandler(mockDb, mockRealtime, mockNormalizedCache, mockSubscriptionManager, mockRehydrationManager, callbacks);
+      await eventHandlers.doc_changed({
+        doctype: "Test",
+        name: "test1"
+      });
+      await eventHandlers.doc_deleted({
+        doctype: "Test",
+        name: "test2"
+      });
+      eventHandlers.perm_epoch_bump();
+      eventHandlers.connected();
+      (0, import_vitest.expect)(callbacks.onRealtimeEvent).toHaveBeenCalledTimes(4);
+      (0, import_vitest.expect)(callbacks.onResetCache).toHaveBeenCalledTimes(1);
+      (0, import_vitest.expect)(callbacks.onBackfillAll).toHaveBeenCalledTimes(1);
+    });
+  });
+});