@multiplatform.one/frappe 6.0.0

package/dist/cjs/realtime.spec.cjs

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