@multiplatform.one/frappe 6.0.4 → 6.3.0

package/dist/cjs/realtime.spec.cjs

@@ -1,326 +0,0 @@
-var import_vitest = require("vitest");
-var import_realtime = require("./realtime.cjs");
-const mockSocket = {
-  connected: false,
-  on: import_vitest.vi.fn(),
-  off: import_vitest.vi.fn(),
-  emit: import_vitest.vi.fn(),
-  connect: import_vitest.vi.fn(),
-  disconnect: import_vitest.vi.fn(),
-  id: "mock-socket-id"
-};
-import_vitest.vi.mock("socket.io-client", () => ({
-  io: import_vitest.vi.fn(() => {
-    return mockSocket;
-  })
-}));
-(0, import_vitest.describe)("RealtimeModule", () => {
-  let realtime;
-  (0, import_vitest.beforeEach)(() => {
-    import_vitest.vi.clearAllMocks();
-    mockSocket.connected = false;
-    mockSocket.on.mockImplementation((event, handler) => {
-      if (event === "connect") {
-        mockSocket.connected = true;
-        setTimeout(() => handler(), 0);
-      }
-    });
-    realtime = new import_realtime.RealtimeModule({
-      baseURL: "http://localhost:3000"
-    });
-  });
-  (0, import_vitest.afterEach)(() => {
-    if (realtime) {
-      realtime.disconnect();
-      realtime = void 0;
-    }
-    import_vitest.vi.clearAllMocks();
-  });
-  (0, import_vitest.describe)("constructor", () => {
-    (0, import_vitest.it)("should initialize without throwing", () => {
-      (0, import_vitest.expect)(() => new import_realtime.RealtimeModule({
-        baseURL: "http://localhost:3000"
-      })).not.toThrow();
-    });
-    (0, import_vitest.it)("should initialize with auth config", () => {
-      const auth = {
-        token: "test-token",
-        useToken: true
-      };
-      (0, import_vitest.expect)(() => new import_realtime.RealtimeModule({
-        baseURL: "http://localhost:3000",
-        auth
-      })).not.toThrow();
-    });
-    (0, import_vitest.it)("should detect platform", () => {
-      const originalUA = global.navigator?.userAgent;
-      Object.defineProperty(global, "navigator", {
-        value: {
-          userAgent: "ReactNative"
-        },
-        writable: true
-      });
-      const rnInstance = new import_realtime.RealtimeModule({
-        baseURL: "http://localhost:3000"
-      });
-      (0, import_vitest.expect)(rnInstance).toBeDefined();
-      if (originalUA) {
-        Object.defineProperty(global, "navigator", {
-          value: {
-            userAgent: originalUA
-          },
-          writable: true
-        });
-      }
-    });
-  });
-  (0, import_vitest.describe)("connect", () => {
-    (0, import_vitest.it)("should establish socket connection", async () => {
-      await realtime.connect();
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("connect", import_vitest.expect.any(Function));
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("disconnect", import_vitest.expect.any(Function));
-    });
-    (0, import_vitest.it)("should not connect twice", async () => {
-      await realtime.connect();
-      const callCount = mockSocket.on.mock.calls.length;
-      await realtime.connect();
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledTimes(callCount);
-    });
-    (0, import_vitest.it)("should handle connection errors", async () => {
-      mockSocket.on.mockImplementation((event, handler) => {
-        if (event === "connect_error") {
-          setTimeout(() => handler(new Error("Connection failed")), 0);
-        }
-      });
-      await realtime.connect();
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("connect_error", import_vitest.expect.any(Function));
-    });
-  });
-  (0, import_vitest.describe)("on", () => {
-    (0, import_vitest.it)("should register event handler and create socket listener dynamically", async () => {
-      const handler = import_vitest.vi.fn();
-      await realtime.on("custom_event", handler);
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("custom_event", import_vitest.expect.any(Function));
-    });
-    (0, import_vitest.it)("should register multiple handlers for same event without duplicating socket listener", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.connect();
-      await realtime.on("doc_changed", handler1);
-      const firstCallCount = mockSocket.on.mock.calls.filter(call => call[0] === "doc_changed").length;
-      await realtime.on("doc_changed", handler2);
-      const secondCallCount = mockSocket.on.mock.calls.filter(call => call[0] === "doc_changed").length;
-      (0, import_vitest.expect)(firstCallCount).toBe(1);
-      (0, import_vitest.expect)(secondCallCount).toBe(1);
-    });
-    (0, import_vitest.it)("should handle any event type", async () => {
-      const events = ["doc_changed", "doc_deleted", "chat_message", "notification", "custom_event", "iot_sensor", "game_state"];
-      await realtime.connect();
-      for (const event of events) {
-        const handler = import_vitest.vi.fn();
-        await realtime.on(event, handler);
-      }
-      events.forEach(event => {
-        const calls = mockSocket.on.mock.calls.filter(call => call[0] === event);
-        (0, import_vitest.expect)(calls.length).toBe(1);
-      });
-    });
-    (0, import_vitest.it)("should forward events to registered handlers", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.on("test_event", handler1);
-      await realtime.on("test_event", handler2);
-      const socketListener = mockSocket.on.mock.calls.find(call => call[0] === "test_event")?.[1];
-      const payload = {
-        data: "test"
-      };
-      socketListener(payload);
-      (0, import_vitest.expect)(handler1).toHaveBeenCalledWith(payload);
-      (0, import_vitest.expect)(handler2).toHaveBeenCalledWith(payload);
-    });
-    (0, import_vitest.it)("should connect automatically when adding first handler", async () => {
-      const handler = import_vitest.vi.fn();
-      await realtime.on("test_event", handler);
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("connect", import_vitest.expect.any(Function));
-    });
-  });
-  (0, import_vitest.describe)("off", () => {
-    (0, import_vitest.it)("should remove event handler", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.on("test_event", handler1);
-      await realtime.on("test_event", handler2);
-      realtime.off("test_event", handler1);
-      const socketListener = mockSocket.on.mock.calls.find(call => call[0] === "test_event")?.[1];
-      const payload = {
-        data: "test"
-      };
-      socketListener(payload);
-      (0, import_vitest.expect)(handler1).not.toHaveBeenCalled();
-      (0, import_vitest.expect)(handler2).toHaveBeenCalledWith(payload);
-    });
-    (0, import_vitest.it)("should remove socket listener when last handler is removed", async () => {
-      const handler = import_vitest.vi.fn();
-      await realtime.on("test_event", handler);
-      realtime.off("test_event", handler);
-      (0, import_vitest.expect)(mockSocket.off).toHaveBeenCalledWith("test_event", import_vitest.expect.any(Function));
-    });
-    (0, import_vitest.it)("should not remove socket listener if other handlers remain", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.on("test_event", handler1);
-      await realtime.on("test_event", handler2);
-      realtime.off("test_event", handler1);
-      (0, import_vitest.expect)(mockSocket.off).not.toHaveBeenCalledWith("test_event");
-    });
-    (0, import_vitest.it)("should handle removing non-existent handler gracefully", () => {
-      const handler = import_vitest.vi.fn();
-      (0, import_vitest.expect)(() => realtime.off("test_event", handler)).not.toThrow();
-    });
-  });
-  (0, import_vitest.describe)("subscribeDoc / unsubscribeDoc", () => {
-    (0, import_vitest.it)("should emit doc_subscribe event", async () => {
-      mockSocket.connected = true;
-      realtime.socketHealthy = true;
-      await realtime.subscribeDoc("Task", "TASK-001");
-      (0, import_vitest.expect)(mockSocket.emit).toHaveBeenCalledWith("doc_subscribe", {
-        doctype: "Task",
-        name: "TASK-001"
-      });
-    });
-    (0, import_vitest.it)("should emit doc_unsubscribe event", async () => {
-      mockSocket.connected = true;
-      realtime.socketHealthy = true;
-      realtime.socket = mockSocket;
-      realtime.unsubscribeDoc("Task", "TASK-001");
-      (0, import_vitest.expect)(mockSocket.emit).toHaveBeenCalledWith("doc_unsubscribe", {
-        doctype: "Task",
-        name: "TASK-001"
-      });
-    });
-    (0, import_vitest.it)("should connect before subscribing if not connected", async () => {
-      await realtime.subscribeDoc("Task", "TASK-001");
-      (0, import_vitest.expect)(mockSocket.on).toHaveBeenCalledWith("connect", import_vitest.expect.any(Function));
-    });
-  });
-  (0, import_vitest.describe)("subscribeList / unsubscribeList", () => {
-    (0, import_vitest.it)("should emit list_subscribe event", async () => {
-      mockSocket.connected = true;
-      realtime.socketHealthy = true;
-      await realtime.subscribeList("Task", {
-        status: "Open"
-      });
-      (0, import_vitest.expect)(mockSocket.emit).toHaveBeenCalledWith("list_subscribe", {
-        doctype: "Task",
-        filters: {
-          status: "Open"
-        }
-      });
-    });
-    (0, import_vitest.it)("should emit list_unsubscribe event", async () => {
-      mockSocket.connected = true;
-      realtime.socketHealthy = true;
-      realtime.socket = mockSocket;
-      realtime.unsubscribeList("Task");
-      (0, import_vitest.expect)(mockSocket.emit).toHaveBeenCalledWith("list_unsubscribe", {
-        doctype: "Task"
-      });
-    });
-  });
-  (0, import_vitest.describe)("isHealthy", () => {
-    (0, import_vitest.it)("should return true when socket is connected and healthy", async () => {
-      await realtime.connect();
-      const connectHandler = mockSocket.on.mock.calls.find(call => call[0] === "connect")?.[1];
-      connectHandler();
-      (0, import_vitest.expect)(realtime.isHealthy()).toBe(true);
-    });
-    (0, import_vitest.it)("should return false when disconnected", () => {
-      (0, import_vitest.expect)(realtime.isHealthy()).toBe(false);
-    });
-    (0, import_vitest.it)("should return false after disconnect event", async () => {
-      await realtime.connect();
-      const connectHandler = mockSocket.on.mock.calls.find(call => call[0] === "connect")?.[1];
-      connectHandler();
-      (0, import_vitest.expect)(realtime.isHealthy()).toBe(true);
-      const disconnectHandler = mockSocket.on.mock.calls.find(call => call[0] === "disconnect")?.[1];
-      disconnectHandler("transport close");
-      (0, import_vitest.expect)(realtime.isHealthy()).toBe(false);
-    });
-  });
-  (0, import_vitest.describe)("disconnect", () => {
-    (0, import_vitest.it)("should disconnect socket", async () => {
-      await realtime.connect();
-      realtime.disconnect();
-      (0, import_vitest.expect)(mockSocket.disconnect).toHaveBeenCalled();
-    });
-    (0, import_vitest.it)("should clear all handlers", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.on("event1", handler1);
-      await realtime.on("event2", handler2);
-      realtime.disconnect();
-      (0, import_vitest.expect)(mockSocket.disconnect).toHaveBeenCalled();
-      const socketListener1 = mockSocket.on.mock.calls.find(call => call[0] === "event1")?.[1];
-      if (socketListener1) {
-        socketListener1({
-          data: "test"
-        });
-        (0, import_vitest.expect)(handler1).not.toHaveBeenCalled();
-      }
-    });
-    (0, import_vitest.it)("should handle multiple disconnects gracefully", () => {
-      (0, import_vitest.expect)(() => {
-        realtime.disconnect();
-        realtime.disconnect();
-      }).not.toThrow();
-    });
-  });
-  (0, import_vitest.describe)("emit", () => {
-    (0, import_vitest.it)("should emit events through socket", async () => {
-      mockSocket.connected = true;
-      realtime.socketHealthy = true;
-      realtime.socket = mockSocket;
-      const payload = {
-        test: "data"
-      };
-      realtime.emit("custom_event", payload);
-      (0, import_vitest.expect)(mockSocket.emit).toHaveBeenCalledWith("custom_event", payload);
-    });
-    (0, import_vitest.it)("should not emit when not connected", () => {
-      const payload = {
-        test: "data"
-      };
-      realtime.emit("custom_event", payload);
-      (0, import_vitest.expect)(mockSocket.emit).not.toHaveBeenCalled();
-    });
-  });
-  (0, import_vitest.describe)("reconnection handling", () => {
-    (0, import_vitest.it)("should re-register existing handlers when connection is re-established", async () => {
-      const handler = import_vitest.vi.fn();
-      await realtime.connect();
-      await realtime.on("test_event", handler);
-      const initialCalls = mockSocket.on.mock.calls.filter(call => call[0] === "test_event");
-      (0, import_vitest.expect)(initialCalls.length).toBe(1);
-      mockSocket.on.mockClear();
-      realtime.socket = void 0;
-      realtime.socketHealthy = false;
-      realtime.isConnecting = false;
-      await realtime.connect();
-      const reconnectCalls = mockSocket.on.mock.calls.filter(call => call[0] === "test_event");
-      (0, import_vitest.expect)(reconnectCalls.length).toBe(1);
-    });
-    (0, import_vitest.it)("should not maintain handlers after explicit disconnect", async () => {
-      const handler1 = import_vitest.vi.fn();
-      const handler2 = import_vitest.vi.fn();
-      await realtime.on("event1", handler1);
-      await realtime.on("event2", handler2);
-      realtime.disconnect();
-      mockSocket.on.mockClear();
-      await realtime.connect();
-      const event1Calls = mockSocket.on.mock.calls.filter(call => call[0] === "event1");
-      const event2Calls = mockSocket.on.mock.calls.filter(call => call[0] === "event2");
-      (0, import_vitest.expect)(event1Calls.length).toBe(0);
-      (0, import_vitest.expect)(event2Calls.length).toBe(0);
-    });
-  });
-});