outdated done.fail callbacks in async tests

Author: dynst

packages/socket/src/queueingstreamingsocket.spec.ts

@@ -15,7 +15,12 @@ describe("QueueingStreamingSocket", () => {
   });
 
   describe("queueRequest", () => {
-    it("can queue and process requests with a connection", (done) => {
+    it("can queue and process requests with a connection", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new QueueingStreamingSocket(socketServerUrl);
       const requests = ["request 1", "request 2", "request 3"] as const;
@@ -35,9 +40,16 @@ describe("QueueingStreamingSocket", () => {
       requests.forEach((request) => {
         socket.queueRequest(request);
       });
+
+      return ret;
     });
 
-    it("can queue requests without a connection and process them later", (done) => {
+    it("can queue requests without a connection and process them later", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new QueueingStreamingSocket(socketServerUrl);
       const requests = ["request 1", "request 2", "request 3"] as const;
@@ -60,11 +72,18 @@ describe("QueueingStreamingSocket", () => {
         expect(socket.getQueueLength()).toEqual(3);
         socket.connect();
       }, 5_000);
+
+      return ret;
     });
   });
 
   describe("reconnect", () => {
-    it("does not emit a completed event when disconnected", (done) => {
+    it("does not emit a completed event when disconnected", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const request = "request";
       const socket = new QueueingStreamingSocket(socketServerUrl);
@@ -84,9 +103,16 @@ describe("QueueingStreamingSocket", () => {
       socket.disconnect();
       socket.reconnect();
       socket.queueRequest(request);
+
+      return ret;
     });
 
-    it("can reconnect and process remaining queue", (done) => {
+    it("can reconnect and process remaining queue", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new QueueingStreamingSocket(socketServerUrl);
       const requests = ["request 1", "request 2", "request 3"] as const;
@@ -110,18 +136,32 @@ describe("QueueingStreamingSocket", () => {
         },
       });
       socket.reconnect();
+
+      return ret;
     });
 
-    it("notifies on reconnection via a callback", (done) => {
+    it("notifies on reconnection via a callback", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new QueueingStreamingSocket(socketServerUrl, undefined, done);
 
       socket.reconnect();
+
+      return ret;
     });
   });
 
   describe("connectionStatus", () => {
-    it("exposes connection status", (done) => {
+    it("exposes connection status", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new QueueingStreamingSocket(socketServerUrl);
       let statusChangesSeen = 0;
@@ -160,6 +200,8 @@ describe("QueueingStreamingSocket", () => {
           socket.disconnect();
         }, 1000);
       }, 1000);
+
+      return ret;
     });
   });
 });

packages/socket/src/reconnectingsocket.spec.ts

@@ -20,7 +20,12 @@ describe("ReconnectingSocket", () => {
   });
 
   describe("connect", () => {
-    it("cannot connect after being connected", (done) => {
+    it("cannot connect after being connected", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new ReconnectingSocket(socketServerUrl);
       // Necessary otherwise the producer doesn’t start
@@ -34,11 +39,18 @@ describe("ReconnectingSocket", () => {
         }).toThrowError(/cannot connect/i);
         done();
       }, 1000);
+
+      return ret;
     });
   });
 
   describe("disconnect", () => {
-    it("ends the events stream", (done) => {
+    it("ends the events stream", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new ReconnectingSocket(socketServerUrl);
       socket.events.subscribe({
@@ -50,9 +62,16 @@ describe("ReconnectingSocket", () => {
       setTimeout(() => {
         socket.disconnect();
       }, 1000);
+
+      return ret;
     });
 
-    it("cannot connect after being disconnected", (done) => {
+    it("cannot connect after being disconnected", async () => {
+      let done!: (() => void) & { fail: (e?: any) => void };
+      const ret = new Promise<void>((resolve, reject) => {
+        done = resolve as typeof done;
+        done.fail = reject;
+      });
       pendingWithoutSocketServer();
       const socket = new ReconnectingSocket(socketServerUrl);
       // Necessary otherwise the producer doesn’t start
@@ -67,6 +86,8 @@ describe("ReconnectingSocket", () => {
         }).toThrowError(/cannot connect/i);
         done();
       }, 1000);
+
+      return ret;
     });
 
     it("can disconnect without waiting for open", () => {

packages/socket/src/socketwrapper.spec.ts

@@ -20,7 +20,12 @@ describe("SocketWrapper", () => {
     expect(socket).toBeTruthy();
   });
 
-  it("can connect", (done) => {
+  it("can connect", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new SocketWrapper(
@@ -38,9 +43,16 @@ describe("SocketWrapper", () => {
     );
     expect(socket).toBeTruthy();
     socket.connect();
+
+    return ret;
   });
 
-  it("fails to connect to non-existing server", (done) => {
+  it("fails to connect to non-existing server", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new SocketWrapper(
@@ -61,9 +73,16 @@ describe("SocketWrapper", () => {
     );
     expect(socket).toBeTruthy();
     socket.connect();
+
+    return ret;
   });
 
-  it("fails to connect to non-existing server but timeout is not triggered", (done) => {
+  it("fails to connect to non-existing server but timeout is not triggered", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
     const timeout = 1200; // ms
 
@@ -86,9 +105,16 @@ describe("SocketWrapper", () => {
     );
     expect(socket).toBeTruthy();
     socket.connect();
+
+    return ret;
   });
 
-  it("can connect to slow server", (done) => {
+  it("can connect to slow server", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new SocketWrapper(
@@ -106,6 +132,8 @@ describe("SocketWrapper", () => {
     );
     expect(socket).toBeTruthy();
     socket.connect();
+
+    return ret;
   });
 
   it("times out when establishing connection takes too long", async () => {
@@ -138,7 +166,12 @@ describe("SocketWrapper", () => {
       });
   });
 
-  it("can connect and disconnect", (done) => {
+  it("can connect and disconnect", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     let opened = 0;
@@ -164,9 +197,16 @@ describe("SocketWrapper", () => {
       },
     );
     socket.connect();
+
+    return ret;
   });
 
-  it("can disconnect before waiting for open", (done) => {
+  it("can disconnect before waiting for open", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new SocketWrapper(
@@ -188,9 +228,16 @@ describe("SocketWrapper", () => {
     );
     socket.connect();
     socket.disconnect();
+
+    return ret;
   });
 
-  it("can disconnect before waiting for open and timeout will not be triggered", (done) => {
+  it("can disconnect before waiting for open and timeout will not be triggered", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
     const timeout = 500; // ms
 
@@ -216,9 +263,16 @@ describe("SocketWrapper", () => {
     );
     socket.connect();
     socket.disconnect();
+
+    return ret;
   });
 
-  it("can send events when connected", (done) => {
+  it("can send events when connected", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const responseMessages = new Array<string>();
@@ -247,9 +301,16 @@ describe("SocketWrapper", () => {
       },
     );
     socket.connect();
+
+    return ret;
   });
 
-  it("can send events after timeout period", (done) => {
+  it("can send events after timeout period", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     // The "timeout period" is the period in which a timeout could potentially be triggered
@@ -275,9 +336,16 @@ describe("SocketWrapper", () => {
     socket.connect();
 
     setTimeout(() => socket.send("Hello world"), 2 * timeoutPeriodLength);
+
+    return ret;
   });
 
-  it("cannot send on a disconnect socket (it will never come back)", (done) => {
+  it("cannot send on a disconnect socket (it will never come back)", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new SocketWrapper(
@@ -304,5 +372,7 @@ describe("SocketWrapper", () => {
       },
     );
     socket.connect();
+
+    return ret;
   });
 });

packages/socket/src/streamingsocket.spec.ts

@@ -76,7 +76,12 @@ describe("StreamingSocket", () => {
     socket.disconnect();
   });
 
-  it("completes stream when disconnected", (done) => {
+  it("completes stream when disconnected", async () => {
+    let done!: (() => void) & { fail: (e?: any) => void };
+    const ret = new Promise<void>((resolve, reject) => {
+      done = resolve as typeof done;
+      done.fail = reject;
+    });
     pendingWithoutSocketServer();
 
     const socket = new StreamingSocket(socketServerUrl);
@@ -96,5 +101,7 @@ describe("StreamingSocket", () => {
       await socket.send("lalala");
       socket.disconnect();
     })().catch(done.fail);
+
+    return ret;
   });
 });