From 7508c3be61f03f8087002150caa1fc4b5e6f545b Mon Sep 17 00:00:00 2001
From: enisdenjo <badurinadenis@gmail.com>
Date: Tue, 9 Aug 2022 14:12:13 +0200
Subject: [PATCH] refactor: better tests cleanup and sometimes dont use
 expect.assertions

https://github.com/facebook/jest/issues/8297
---
 src/__tests__/client.ts         | 23 ++++++++++++++---------
 src/__tests__/utils/tservers.ts | 24 +++++++++++++++---------
 2 files changed, 29 insertions(+), 18 deletions(-)

diff --git a/src/__tests__/client.ts b/src/__tests__/client.ts
index fbdb6a51..0d5ce1dc 100644
--- a/src/__tests__/client.ts
+++ b/src/__tests__/client.ts
@@ -1466,10 +1466,9 @@ describe('reconnecting', () => {
     });
 
     // client reported the error immediately, meaning it wont retry
-    expect.assertions(1);
     await sub.waitForError((err) => {
       expect((err as CloseEvent).code).toBe(1005);
-    }, 20);
+    });
   });
 
   it('should reconnect silently after socket closes', async () => {
@@ -1504,10 +1503,9 @@ describe('reconnecting', () => {
     });
 
     // client reported the error, meaning it wont retry anymore
-    expect.assertions(1);
     await sub.waitForError((err) => {
       expect((err as CloseEvent).code).toBe(1005);
-    }, 20);
+    });
   });
 
   it('should resubscribe all subscribers on silent reconnects', async () => {
@@ -1629,10 +1627,9 @@ describe('reconnecting', () => {
       // client reported the error immediately, meaning it wont retry
       await sub.waitForError((err) => {
         expect((err as CloseEvent).code).toBe(code);
-      }, 20);
+      });
     }
 
-    expect.assertions(8);
     const warn = console.warn;
     console.warn = () => {
       /* hide warnings for test */
@@ -2063,7 +2060,6 @@ describe('events', () => {
 
   it('should emit the websocket connection error', (done) => {
     expect.assertions(3);
-
     createClient({
       url: 'ws://localhost/i/dont/exist',
       lazy: false,
@@ -2087,7 +2083,8 @@ describe('events', () => {
   });
 
   it('should emit the websocket connection error on first subscribe in lazy mode', (done) => {
-    expect.assertions(3);
+    // dont use expect.assertions(3) because https://github.com/facebook/jest/issues/8297
+    const expected = jest.fn();
 
     const client = createClient({
       url: 'ws://localhost/i/dont/exist',
@@ -2097,11 +2094,13 @@ describe('events', () => {
     client.on('closed', (err) => {
       // websocket closed
       expect((err as CloseEvent).code).toBe(1006);
+      expected();
     });
 
     client.on('error', (err) => {
       // connection error
       expect((err as ErrorEvent).message).toContain('connect ECONNREFUSED');
+      expected();
     });
 
     client.subscribe(
@@ -2112,6 +2111,7 @@ describe('events', () => {
         error: (err) => {
           // connection error
           expect((err as ErrorEvent).message).toContain('connect ECONNREFUSED');
+          expect(expected).toBeCalledTimes(2);
           done();
         },
       },
@@ -2209,6 +2209,9 @@ describe('events', () => {
   });
 
   it('should provide the latest socket reference to event listeners', async () => {
+    // dont use expect.assertions(6) because https://github.com/facebook/jest/issues/8297
+    const expected = jest.fn();
+
     const { url, ...server } = await startTServer();
 
     const client = createClient({
@@ -2221,11 +2224,13 @@ describe('events', () => {
           // only latest socket can be open
           const sock = socket as WebSocket;
           expect(sock.readyState).toBe(sock.OPEN);
+          expected();
         },
         connected: (socket) => {
           // only latest socket can be open
           const sock = socket as WebSocket;
           expect(sock.readyState).toBe(sock.OPEN);
+          expected();
         },
       },
     });
@@ -2257,6 +2262,6 @@ describe('events', () => {
     await tsubscribe(client, { query: '{ getValue }' }).waitForComplete();
 
     // opened and connected should be called 6 times (3 times connected, 2 times disconnected)
-    expect.assertions(6);
+    expect(expected).toBeCalledTimes(6);
   });
 });
diff --git a/src/__tests__/utils/tservers.ts b/src/__tests__/utils/tservers.ts
index f7daed43..88a9c1e8 100644
--- a/src/__tests__/utils/tservers.ts
+++ b/src/__tests__/utils/tservers.ts
@@ -23,12 +23,9 @@ export { WSExtra, UWSExtra, FastifyExtra };
 
 // distinct server for each test; if you forget to dispose, the fixture wont
 const leftovers: Dispose[] = [];
-afterEach(async () => {
+afterAll(async () => {
   while (leftovers.length > 0) {
-    // if not disposed by test, cleanup
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const dispose = leftovers.pop()!;
-    await dispose();
+    await leftovers.pop()?.();
   }
 });
 
@@ -116,15 +113,17 @@ export async function startRawServer(): Promise<{
     socket.once('close', () => sockets.delete(socket));
   });
 
+  let disposed = false;
   const dispose: Dispose = (beNice) => {
     return new Promise((resolve) => {
+      if (disposed) return resolve();
+      disposed = true;
       if (!beNice)
         for (const socket of sockets) {
           socket.terminate();
           sockets.delete(socket);
         }
       server.close(() => {
-        leftovers.splice(leftovers.indexOf(dispose), 1);
         resolve();
       });
     });
@@ -194,8 +193,11 @@ export async function startWSTServer(
     keepAlive,
   );
 
+  let disposed = false;
   const dispose: Dispose = (beNice) => {
     return new Promise((resolve, reject) => {
+      if (disposed) return resolve();
+      disposed = true;
       if (!beNice)
         for (const socket of sockets) {
           socket.terminate();
@@ -204,7 +206,6 @@ export async function startWSTServer(
       const disposing = server.dispose() as Promise<void>;
       disposing.catch(reject).then(() => {
         wsServer.close(() => {
-          leftovers.splice(leftovers.indexOf(dispose), 1);
           resolve();
         });
       });
@@ -393,13 +394,15 @@ export async function startUWSTServer(
     },
   );
 
+  let disposed = false;
   const dispose: Dispose = async (beNice) => {
+    if (disposed) return;
+    disposed = true;
     for (const socket of sockets) {
       if (beNice) socket.end(1001, 'Going away');
       else socket.close();
     }
     uWS.us_listen_socket_close(listenSocket);
-    leftovers.splice(leftovers.indexOf(dispose), 1);
   };
   leftovers.push(dispose);
 
@@ -541,8 +544,12 @@ export async function startFastifyWSTServer(
     });
   });
 
+  let disposed = false;
   const dispose: Dispose = (beNice) => {
     return new Promise((resolve, reject) => {
+      if (disposed) return resolve();
+      disposed = true;
+
       for (const socket of sockets) {
         if (beNice) socket.close(1001, 'Going away');
         else socket.terminate();
@@ -552,7 +559,6 @@ export async function startFastifyWSTServer(
       fastify.websocketServer.close((err) => {
         if (err) return reject(err);
         fastify.close(() => {
-          leftovers.splice(leftovers.indexOf(dispose), 1);
           resolve();
         });
       });