@multiplatform.one/frappe 6.1.0 → 6.4.0

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

@@ -1,499 +0,0 @@
-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);
-    });
-  });
-});