test: test connection state recovery with ioredis and cluster (#15)

Author: NamPNQ

test/connection-state-recovery.ts

@@ -1,61 +1,28 @@
-import { createServer } from "http";
 import { Server } from "socket.io";
-import expect = require("expect.js");
 import { io as ioc } from "socket.io-client";
-import { createAdapter } from "../lib";
-import { AddressInfo } from "net";
-import { createClient } from "redis";
-import { sleep } from "./util";
-
-const NODES_COUNT = 3;
+import { setup, sleep } from "./util";
+import expect = require("expect.js");
 
 describe("connection state recovery", () => {
-  let servers: Server[], ports: number[], redisClients: any[];
+  let servers: Server[], ports: number[], cleanup;
 
   beforeEach(async () => {
-    servers = [];
-    ports = [];
-    redisClients = [];
-
-    return new Promise(async (resolve) => {
-      for (let i = 1; i <= NODES_COUNT; i++) {
-        const redisClient = createClient();
-
-        await redisClient.connect();
-
-        const httpServer = createServer();
-        const io = new Server(httpServer, {
-          adapter: createAdapter(redisClient),
-          connectionStateRecovery: {
-            maxDisconnectionDuration: 5000,
-          },
-        });
-        httpServer.listen(async () => {
-          const port = (httpServer.address() as AddressInfo).port;
-
-          ports.push(port);
-          servers.push(io);
-          redisClients.push(redisClient);
-          if (servers.length === NODES_COUNT) {
-            await sleep(200);
-
-            resolve();
-          }
-        });
-      }
+    const testContext = await setup({
+      nodeCount: 3,
+      serverOptions: {
+        connectionStateRecovery: {
+          maxDisconnectionDuration: 5000,
+        },
+      },
     });
+    servers = testContext.servers;
+    cleanup = testContext.cleanup;
+    ports = testContext.ports;
   });
 
   afterEach(() => {
-    servers.forEach((server) => {
-      // @ts-ignore
-      server.httpServer.close();
-      server.of("/").adapter.close();
-      servers[0].of("/foo").adapter.close();
-    });
-    redisClients.forEach((redisClient) => {
-      redisClient.quit();
-    });
+    servers[0].of("/foo").adapter.close();
+    cleanup();
   });
 
   it("should restore the session", (done) => {

test/util.ts

@@ -1,4 +1,4 @@
-import { Server } from "socket.io";
+import { Server, ServerOptions } from "socket.io";
 import { Socket as ServerSocket } from "socket.io/dist/socket";
 import { io as ioc, Socket as ClientSocket } from "socket.io-client";
 import { createClient, createCluster } from "redis";
@@ -30,6 +30,7 @@ interface TestContext {
   serverSockets: ServerSocket[];
   clientSockets: ClientSocket[];
   cleanup: () => void;
+  ports: number[];
 }
 
 const mode = process.env.REDIS_CLUSTER === "1" ? "cluster" : "standalone";
@@ -99,27 +100,35 @@ async function initRedisClient() {
       return new Redis();
     } else {
       const redisClient = createClient();
-
       await redisClient.connect();
 
       return redisClient;
     }
   }
 }
 
-export function setup() {
+type SetupOptions = {
+  nodeCount?: number;
+  serverOptions?: Partial<ServerOptions>;
+};
+export function setup({
+  nodeCount = NODES_COUNT,
+  serverOptions = {},
+}: SetupOptions = {}) {
   const servers = [];
   const serverSockets = [];
   const clientSockets = [];
   const redisClients = [];
+  const ports = [];
 
   return new Promise<TestContext>(async (resolve) => {
-    for (let i = 1; i <= NODES_COUNT; i++) {
+    for (let i = 1; i <= nodeCount; i++) {
       const redisClient = await initRedisClient();
 
       const httpServer = createServer();
       const io = new Server(httpServer, {
         adapter: createAdapter(redisClient),
+        ...serverOptions,
       });
       httpServer.listen(() => {
         const port = (httpServer.address() as AddressInfo).port;
@@ -130,13 +139,15 @@ export function setup() {
           serverSockets.push(socket);
           servers.push(io);
           redisClients.push(redisClient);
-          if (servers.length === NODES_COUNT) {
+          ports.push(port);
+          if (servers.length === nodeCount) {
             await sleep(200);
 
             resolve({
               servers,
               serverSockets,
               clientSockets,
+              ports,
               cleanup: () => {
                 servers.forEach((server) => {
                   // @ts-ignore