cojson-transport-ws 0.9.23 → 0.10.0

package/src/tests/WebSocketPeerWithReconnection.test.ts

@@ -0,0 +1,143 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { WebSocketPeerWithReconnection } from "../WebSocketPeerWithReconnection";
+import { startSyncServer } from "./syncServer";
+import { waitFor } from "./utils";
+
+describe("WebSocketPeerWithReconnection", () => {
+  let server: any;
+  let syncServerUrl: string;
+
+  beforeEach(async () => {
+    const result = await startSyncServer();
+    server = result;
+    syncServerUrl = result.syncServer;
+  });
+
+  afterEach(() => {
+    server.close();
+  });
+
+  test("should connect successfully to sync server", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for connection to establish
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(addPeer).toHaveBeenCalledTimes(1);
+    expect(removePeer).not.toHaveBeenCalled();
+
+    peer.disable();
+  });
+
+  test("should attempt reconnection when server disconnects", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    addPeer.mockClear();
+
+    // Close server to simulate disconnect
+    server.close();
+
+    // Wait for disconnect to be detected
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    expect(removePeer).toHaveBeenCalled();
+    expect(peer.reconnectionAttempts).toBeGreaterThan(0);
+
+    // Start server again
+    server = await startSyncServer(server.port);
+
+    // Wait for reconnection
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(addPeer).toHaveBeenCalled();
+
+    peer.disable();
+  });
+
+  test("should stop reconnection attempts when disabled", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 100,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Close server and disable peer
+    server.close();
+    peer.disable();
+
+    // Wait to ensure no reconnection attempts
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    expect(addPeer).toHaveBeenCalledTimes(1);
+    expect(removePeer).toHaveBeenCalledTimes(1);
+    expect(peer.reconnectionAttempts).toBe(0);
+  });
+
+  test("should reset reconnection attempts when connection is successful", async () => {
+    const addPeer = vi.fn();
+    const removePeer = vi.fn();
+
+    const peer = new WebSocketPeerWithReconnection({
+      peer: syncServerUrl,
+      reconnectionTimeout: 10,
+      addPeer,
+      removePeer,
+    });
+
+    peer.enable();
+
+    // Wait for initial connection
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Close server to trigger reconnection attempts
+    server.close();
+
+    // Wait for some reconnection attempts
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    const previousAttempts = peer.reconnectionAttempts;
+    expect(previousAttempts).toBeGreaterThan(0);
+
+    // Start server again
+    server = await startSyncServer(server.port);
+
+    // Wait for successful reconnection
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    await waitFor(() => expect(peer.reconnectionAttempts).toBe(0));
+
+    peer.disable();
+  });
+});

package/src/tests/createWebSocketPeer.test.ts

@@ -7,7 +7,7 @@ import {
   BUFFER_LIMIT_POLLING_INTERVAL,
   CreateWebSocketPeerOpts,
   createWebSocketPeer,
-} from "../index.js";
+} from "../createWebSocketPeer.js";
 import { AnyWebSocket } from "../types.js";
 
 function setup(opts: Partial<CreateWebSocketPeerOpts> = {}) {

package/src/tests/integration.test.ts

@@ -1,7 +1,7 @@
 import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
 import { afterEach, beforeEach, describe, expect, test } from "vitest";
 import { WebSocket } from "ws";
-import { createWebSocketPeer } from "../index";
+import { createWebSocketPeer } from "../createWebSocketPeer";
 import { startSyncServer } from "./syncServer";
 
 describe("WebSocket Peer Integration", () => {
@@ -86,7 +86,6 @@ describe("WebSocket Peer Integration", () => {
 
     // Wait for sync
     await map.core.waitForSync();
-    console.log("synced");
 
     // Verify data reached the server
     const serverNode = server.localNode;

package/src/tests/syncServer.ts

@@ -1,7 +1,7 @@
 import { createServer } from "http";
 import { ControlledAgent, LocalNode, WasmCrypto } from "cojson";
 import { WebSocket, WebSocketServer } from "ws";
-import { createWebSocketPeer } from "../index";
+import { createWebSocketPeer } from "../createWebSocketPeer";
 
 export const startSyncServer = async (port?: number) => {
   const crypto = await WasmCrypto.create();

package/src/tests/utils.ts

@@ -0,0 +1,27 @@
+export function waitFor(callback: () => boolean | void) {
+  return new Promise<void>((resolve, reject) => {
+    const checkPassed = () => {
+      try {
+        return { ok: callback(), error: null };
+      } catch (error) {
+        return { ok: false, error };
+      }
+    };
+
+    let retries = 0;
+
+    const interval = setInterval(() => {
+      const { ok, error } = checkPassed();
+
+      if (ok !== false) {
+        clearInterval(interval);
+        resolve();
+      }
+
+      if (++retries > 10) {
+        clearInterval(interval);
+        reject(error);
+      }
+    }, 100);
+  });
+}