test: refactor test setup

Author: darrachequesne

test/index.ts

@@ -1,81 +1,23 @@
-import { createServer } from "http";
-import { Server, Socket as ServerSocket } from "socket.io";
-import { io as ioc, Socket as ClientSocket } from "socket.io-client";
-import expect = require("expect.js");
-import { createAdapter } from "../lib";
-import type { AddressInfo } from "net";
-import { times, sleep, shouldNotHappen } from "./util";
-import { Pool } from "pg";
-
-const NODES_COUNT = 3;
+import { type Server, type Socket as ServerSocket } from "socket.io";
+import { type Socket as ClientSocket } from "socket.io-client";
+import expect from "expect.js";
+import { setup, times, sleep, shouldNotHappen } from "./util";
 
 describe("@socket.io/postgres-adapter", () => {
   let servers: Server[],
     serverSockets: ServerSocket[],
     clientSockets: ClientSocket[],
-    pool: Pool;
-
-  beforeEach((done) => {
-    servers = [];
-    serverSockets = [];
-    clientSockets = [];
-    pool = new Pool({
-      user: "postgres",
-      host: "localhost",
-      database: "postgres",
-      password: "changeit",
-      port: 5432,
-    });
-
-    pool.query(
-      `
-      CREATE TABLE IF NOT EXISTS events (
-          id          bigserial UNIQUE,
-          created_at  timestamptz DEFAULT NOW(),
-          payload     bytea
-      );
-    `,
-      () => {}
-    );
-
-    for (let i = 1; i <= NODES_COUNT; i++) {
-      const httpServer = createServer();
-      const io = new Server(httpServer);
-      io.adapter(
-        createAdapter(pool, {
-          tableName: "events",
-        })
-      );
-      httpServer.listen(() => {
-        const port = (httpServer.address() as AddressInfo).port;
-        const clientSocket = ioc(`http://localhost:${port}`);
-
-        io.on("connection", async (socket) => {
-          clientSockets.push(clientSocket);
-          serverSockets.push(socket);
-          servers.push(io);
-          if (servers.length === NODES_COUNT) {
-            await sleep(200);
-
-            // ensure all nodes know each other
-            servers[0].emit("ping");
-            servers[1].emit("ping");
-            servers[2].emit("ping");
-
-            await sleep(200);
-
-            done();
-          }
-        });
-      });
-    }
+    cleanup: () => void;
+
+  beforeEach(async () => {
+    const testContext = await setup();
+    servers = testContext.servers;
+    serverSockets = testContext.serverSockets;
+    clientSockets = testContext.clientSockets;
+    cleanup = testContext.cleanup;
   });
 
-  afterEach((done) => {
-    servers.forEach((server) => server.close());
-    clientSockets.forEach((socket) => socket.disconnect());
-    pool.end(done);
-  });
+  afterEach(() => cleanup());
 
   describe("broadcast", function () {
     it("broadcasts to all clients", (done) => {

test/util.ts

@@ -1,3 +1,10 @@
+import { createServer } from "http";
+import { AddressInfo } from "net";
+import { Server, type Socket as ServerSocket } from "socket.io";
+import { io as ioc, type Socket as ClientSocket } from "socket.io-client";
+import { Pool } from "pg";
+import { createAdapter } from "../lib";
+
 export function times(count: number, done: (err?: Error) => void) {
   let i = 0;
   return () => {
@@ -17,3 +24,73 @@ export function sleep(duration: number) {
 export function shouldNotHappen(done: (err?: Error) => void) {
   return () => done(new Error("should not happen"));
 }
+
+interface TestContext {
+  servers: Server[];
+  serverSockets: ServerSocket[];
+  clientSockets: ClientSocket[];
+  cleanup: () => void;
+}
+
+const NODES_COUNT = 3;
+
+export function setup() {
+  const servers: Server[] = [];
+  const serverSockets: ServerSocket[] = [];
+  const clientSockets: ClientSocket[] = [];
+
+  const pool = new Pool({
+    user: "postgres",
+    password: "changeit",
+  });
+
+  return new Promise<TestContext>(async (resolve) => {
+    await pool.query(
+      `
+      CREATE TABLE IF NOT EXISTS events (
+          id          bigserial UNIQUE,
+          created_at  timestamptz DEFAULT NOW(),
+          payload     bytea
+      );
+    `,
+      () => {}
+    );
+
+    for (let i = 1; i <= NODES_COUNT; i++) {
+      const httpServer = createServer();
+      const io = new Server(httpServer, {
+        adapter: createAdapter(pool, {
+          tableName: "events",
+        }),
+      });
+
+      io.of("/").adapter.init();
+
+      httpServer.listen(() => {
+        const port = (httpServer.address() as AddressInfo).port;
+        const clientSocket = ioc(`http://localhost:${port}`);
+
+        io.on("connection", async (socket) => {
+          clientSockets.push(clientSocket);
+          serverSockets.push(socket);
+          servers.push(io);
+
+          if (servers.length === NODES_COUNT) {
+            await sleep(100);
+
+            resolve({
+              servers,
+              serverSockets,
+              clientSockets,
+              cleanup: () => {
+                servers.forEach((server) => server.close());
+                clientSockets.forEach((socket) => socket.disconnect());
+                pool.end();
+              },
+            });
+          }
+        });
+      });
+    }
+  });
+}