fix types and add more reliable tests (#2621)

2 files changed, 363 insertions, 312 deletions

diff --git a/test/js/node/net/node-net-server.test.ts b/test/js/node/net/node-net-server.test.ts
index 86887b437..88a77526c 100644
--- a/test/js/node/net/node-net-server.test.ts
+++ b/test/js/node/net/node-net-server.test.ts
@@ -1,12 +1,10 @@
-const { createServer } = require("net");
+import { createServer, Server, AddressInfo, Socket } from "net";
 import { realpathSync } from "fs";
 import { tmpdir } from "os";
 import { join } from "path";
 import { createTest } from "node-harness";
 
-const { throws, assert, createDoneDotAll, beforeAll, describe, expect, it, createCallCheckCtx } = createTest(
-  import.meta.path,
-);
+const { describe, expect, it, createCallCheckCtx } = createTest(import.meta.path);
 
 const socket_domain = join(realpathSync(tmpdir()), "node-net-server.sock");
 
@@ -21,155 +19,236 @@ describe("net.createServer listen", () => {
   it("should listen on IPv6 by default", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
-
-    server.on("error", mustNotCall());
+    const server: Server = createServer();
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       0,
       mustCall(() => {
-        const address = server.address();
+        const address = server.address() as AddressInfo;
         expect(address.address).toStrictEqual("::");
         //system should provide an port when 0 or no port is passed
         expect(address.port).toBeGreaterThan(100);
         expect(address.family).toStrictEqual("IPv6");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen on IPv4", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       0,
-      "127.0.0.1",
+      "0.0.0.0",
       mustCall(() => {
-        const address = server.address();
-        expect(address.address).toStrictEqual("127.0.0.1");
+        const address = server.address() as AddressInfo;
+        expect(address.address).toStrictEqual("0.0.0.0");
         //system should provide an port when 0 or no port is passed
         expect(address.port).toBeGreaterThan(100);
         expect(address.family).toStrictEqual("IPv4");
         server.close();
+        done();
       }),
     );
-    done();
+  });
+
+  it("should call listening", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
+
+    const server: Server = createServer();
+
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+
+    server.on("error", closeAndFail).on(
+      "listening",
+      mustCall(() => {
+        clearTimeout(timeout);
+        server.close();
+        done();
+      }),
+    );
+
+    timeout = setTimeout(closeAndFail, 100);
+
+    server.listen(0, "0.0.0.0");
   });
 
   it("should listen on localhost", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       0,
       "::1",
       mustCall(() => {
-        const address = server.address();
+        const address = server.address() as AddressInfo;
         expect(address.address).toStrictEqual("::1");
         //system should provide an port when 0 or no port is passed
         expect(address.port).toBeGreaterThan(100);
         expect(address.family).toStrictEqual("IPv6");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen on localhost", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       0,
       "::1",
       mustCall(() => {
-        const address = server.address();
+        const address = server.address() as AddressInfo;
         expect(address.address).toStrictEqual("::1");
         expect(address.family).toStrictEqual("IPv6");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen without port or host", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       mustCall(() => {
-        const address = server.address();
+        const address = server.address() as AddressInfo;
         expect(address.address).toStrictEqual("::");
         //system should provide an port when 0 or no port is passed
         expect(address.port).toBeGreaterThan(100);
         expect(address.family).toStrictEqual("IPv6");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen on the correct port", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       49027,
       mustCall(() => {
-        const address = server.address();
+        const address = server.address() as AddressInfo;
         expect(address.address).toStrictEqual("::");
         expect(address.port).toStrictEqual(49027);
         expect(address.family).toStrictEqual("IPv6");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen on the correct port with IPV4", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       49026,
-      "127.0.0.1",
+      "0.0.0.0",
       mustCall(() => {
-        const address = server.address();
-        expect(address.address).toStrictEqual("127.0.0.1");
+        const address = server.address() as AddressInfo;
+        expect(address.address).toStrictEqual("0.0.0.0");
         expect(address.port).toStrictEqual(49026);
         expect(address.family).toStrictEqual("IPv4");
         server.close();
+        done();
       }),
     );
-    done();
   });
 
   it("should listen on unix domain socket", done => {
     const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-    const server = createServer();
+    const server: Server = createServer();
 
-    server.on("error", mustNotCall());
+    let timeout: Timer;
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall()();
+    };
+    server.on("error", closeAndFail);
+    timeout = setTimeout(closeAndFail, 100);
 
     server.listen(
       socket_domain,
@@ -177,315 +256,287 @@ describe("net.createServer listen", () => {
         const address = server.address();
         expect(address).toStrictEqual(socket_domain);
         server.close();
+        done();
       }),
     );
-    done();
   });
 });
 
-it("should receive data", done => {
-  const { mustCall, mustNotCall } = createCallCheckCtx(done);
-  let timeout: number | Timer;
-
-  const onData = mustCall(data => {
-    clearTimeout(timeout);
-    server.close();
-    expect(data.byteLength).toBe(5);
-    expect(data.toString("utf8")).toBe("Hello");
-    done();
-  });
-
-  const server = createServer((socket: any) => {
-    socket.on("data", onData);
-  });
-
-  const closeAndFail = mustNotCall("no data received (timeout)", () => {
-    clearTimeout(timeout);
-    server.close();
-  });
-
-  server.on("error", mustNotCall("no data received"));
-
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-
-  server.listen(
-    mustCall(() => {
-      const address = server.address();
-      Bun.connect({
-        hostname: address.address,
-        port: address.port,
-        socket: {
-          data(socket) {},
-          open(socket) {
-            socket.write("Hello");
-            socket.end();
-          },
-          connectError: closeAndFail, // connection failed
-        },
-      }).catch(closeAndFail);
-    }),
-  );
-});
+describe("tls.createServer events", () => {
+  it("should receive data", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
+    let timeout: Timer;
+    let client: any = null;
+    let is_done = false;
+    const onData = mustCall(data => {
+      is_done = true;
+      clearTimeout(timeout);
+      server.close();
+      expect(data.byteLength).toBe(5);
+      expect(data.toString("utf8")).toBe("Hello");
+      done();
+    });
 
-it("should call end", done => {
-  const { mustCall, mustNotCall } = createCallCheckCtx(done);
-  let timeout: number | Timer;
+    const server: Server = createServer((socket: Socket) => {
+      socket.on("data", onData);
+    });
 
-  const onEnd = mustCall(() => {
-    clearTimeout(timeout);
-    server.close();
-    done();
-  });
+    const closeAndFail = () => {
+      if (is_done) return;
+      clearTimeout(timeout);
+      server.close();
+      client?.end();
+      mustNotCall("no data received")();
+    };
 
-  const server = createServer((socket: any) => {
-    socket.on("end", onEnd);
-    socket.end();
-  });
+    server.on("error", closeAndFail);
 
-  const closeAndFail = mustNotCall("end not called (timeout)", () => {
-    clearTimeout(timeout);
-    server.close();
-  });
-  server.on("error", mustNotCall("end not called"));
-
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-
-  server.listen(
-    mustCall(() => {
-      const address = server.address();
-      Bun.connect({
-        hostname: address.address,
-        port: address.port,
-        socket: {
-          data(socket) {},
-          open(socket) {},
-          connectError: closeAndFail, // connection failed
-        },
-      }).catch(closeAndFail);
-    }),
-  );
-});
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
 
-it("should call close", done => {
-  let closed = false;
-  const server = createServer();
-  server.listen().on("close", () => {
-    closed = true;
+    server.listen(
+      mustCall(async () => {
+        const address = server.address() as AddressInfo;
+        client = await Bun.connect({
+          hostname: address.address,
+          port: address.port,
+          socket: {
+            data(socket) {},
+            open(socket) {
+              if (socket.write("Hello")) {
+                socket.end();
+              }
+            },
+            connectError: closeAndFail, // connection failed
+          },
+        }).catch(closeAndFail);
+      }),
+    );
   });
-  server.close();
-  expect(closed).toBe(true);
-  done();
-});
 
-it("should call connection and drop", done => {
-  const { mustCall, mustNotCall } = createCallCheckCtx(done);
+  it("should call end", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
+    let timeout: Timer;
+    let is_done = false;
+    const onEnd = mustCall(() => {
+      is_done = true;
+      clearTimeout(timeout);
+      server.close();
+      done();
+    });
 
-  let timeout: number | Timer;
-  const server = createServer();
-  let maxClients = 2;
-  server.maxConnections = maxClients - 1;
+    const server: Server = createServer((socket: Socket) => {
+      socket.on("end", onEnd);
+      socket.end();
+    });
 
-  const closeAndFail = mustNotCall("drop not called (timeout)", () => {
-    clearTimeout(timeout);
-    server.close();
-    done();
-  });
+    const closeAndFail = () => {
+      if (is_done) return;
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall("end not called")();
+    };
+    server.on("error", closeAndFail);
 
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-  let connection_called = false;
-  server
-    .on(
-      "connection",
-      mustCall(() => {
-        connection_called = true;
-      }),
-    )
-    .on(
-      "drop",
-      mustCall(data => {
-        server.close();
-        clearTimeout(timeout);
-        expect(data.localPort).toBeDefined();
-        expect(data.remotePort).toBeDefined();
-        expect(data.remoteFamily).toBeDefined();
-        expect(data.localFamily).toBeDefined();
-        expect(data.localAddress).toBeDefined();
-        expect(connection_called).toBe(true);
-        done();
-      }),
-    )
-    .listen(() => {
-      const address = server.address();
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
 
-      function spawnClient() {
-        Bun.connect({
-          port: address.port,
+    server.listen(
+      mustCall(async () => {
+        const address = server.address() as AddressInfo;
+        await Bun.connect({
           hostname: address.address,
+          port: address.port,
           socket: {
             data(socket) {},
-            open(socket) {
-              socket.end();
-            },
+            open(socket) {},
+            connectError: closeAndFail, // connection failed
           },
-        }).catch(e => {
-          closeAndFail();
-        });
-      }
-      for (let i = 0; i < maxClients; i++) {
-        spawnClient();
-        spawnClient();
-      }
-    });
-});
-
-it("should call listening", done => {
-  const { mustCall, mustNotCall } = createCallCheckCtx(done);
-
-  let timeout: number | Timer;
-  const server = createServer();
-  let maxClients = 2;
-  server.maxConnections = maxClients - 1;
+        }).catch(closeAndFail);
+      }),
+    );
+  });
 
-  const closeAndFail = mustNotCall("listening not called (timeout)", () => {
-    clearTimeout(timeout);
+  it("should call close", done => {
+    let closed = false;
+    const server: Server = createServer();
+    server.listen().on("close", () => {
+      closed = true;
+    });
     server.close();
+    expect(closed).toBe(true);
     done();
   });
 
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-
-  server
-    .on(
-      "listening",
-      mustCall(() => {
-        server.close();
-        clearTimeout(timeout);
-        done();
-      }),
-    )
-    .listen();
-});
-
-it("should call error", done => {
-  const { mustCall, mustNotCall, closeTimers } = createCallCheckCtx(done);
-
-  let timeout: number | Timer;
-  const server = createServer();
-  let maxClients = 2;
-  server.maxConnections = maxClients - 1;
+  it("should call connection and drop", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-  const closeAndFail = mustNotCall("error not called (timeout)", () => {
-    clearTimeout(timeout);
-    closeTimers();
-    server.close();
+    let timeout: Timer;
+    let is_done = false;
+    const server = createServer();
+    let maxClients = 2;
+    server.maxConnections = maxClients - 1;
+
+    const closeAndFail = () => {
+      if (is_done) return;
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall("drop not called")();
+    };
+
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
+    let connection_called = false;
+    server
+      .on(
+        "connection",
+        mustCall(() => {
+          connection_called = true;
+        }),
+      )
+      .on(
+        "drop",
+        mustCall(data => {
+          is_done = true;
+          server.close();
+          clearTimeout(timeout);
+          expect(data.localPort).toBeDefined();
+          expect(data.remotePort).toBeDefined();
+          expect(data.remoteFamily).toBeDefined();
+          expect(data.localFamily).toBeDefined();
+          expect(data.localAddress).toBeDefined();
+          expect(connection_called).toBe(true);
+          done();
+        }),
+      )
+      .listen(async () => {
+        const address = server.address() as AddressInfo;
+
+        async function spawnClient() {
+          await Bun.connect({
+            port: address?.port,
+            hostname: address?.address,
+            socket: {
+              data(socket) {},
+              open(socket) {
+                socket.end();
+              },
+            },
+          });
+        }
+
+        const promises = [];
+        for (let i = 0; i < maxClients; i++) {
+          promises.push(spawnClient());
+        }
+        await Promise.all(promises).catch(closeAndFail);
+      });
   });
 
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
+  it("should call error", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-  server
-    .on(
-      "error",
-      mustCall(err => {
-        server.close();
-        clearTimeout(timeout);
-        closeTimers();
-        expect(err).toBeDefined();
-        done();
-      }),
-    )
-    .listen(123456);
-});
+    let timeout: Timer;
+    const server: Server = createServer();
+
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall("error not called")();
+    };
+
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
+
+    server
+      .on(
+        "error",
+        mustCall(err => {
+          server.close();
+          clearTimeout(timeout);
+          expect(err).toBeDefined();
+          done();
+        }),
+      )
+      .listen(123456);
+  });
 
-it("should call abort with signal", done => {
-  const { mustCall, mustNotCall, closeTimers } = createCallCheckCtx(done);
+  it("should call abort with signal", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
 
-  const controller = new AbortController();
-  let timeout: number | Timer;
-  const server = createServer();
-  let maxClients = 2;
-  server.maxConnections = maxClients - 1;
+    const controller = new AbortController();
+    let timeout: Timer;
+    const server = createServer();
 
-  const closeAndFail = mustNotCall("close not called (timeout)", () => {
-    clearTimeout(timeout);
-    server.close();
+    const closeAndFail = () => {
+      clearTimeout(timeout);
+      server.close();
+      mustNotCall("close not called")();
+    };
+
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
+
+    server
+      .on(
+        "close",
+        mustCall(() => {
+          clearTimeout(timeout);
+          done();
+        }),
+      )
+      .listen({ port: 0, signal: controller.signal }, () => {
+        controller.abort();
+      });
   });
 
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-
-  server
-    .on(
-      "close",
-      mustCall(() => {
-        clearTimeout(timeout);
-        closeTimers();
-        done();
-      }),
-    )
-    .listen({ port: 0, signal: controller.signal }, () => {
-      controller.abort();
+  it("should echo data", done => {
+    const { mustCall, mustNotCall } = createCallCheckCtx(done);
+    let timeout: Timer;
+    let client: any = null;
+    const server: Server = createServer((socket: Socket) => {
+      socket.pipe(socket);
     });
-});
+    let is_done = false;
+    const closeAndFail = () => {
+      if (is_done) return;
+      clearTimeout(timeout);
+      server.close();
+      client?.end();
+      mustNotCall("no data received")();
+    };
 
-it("should echo data", done => {
-  const { mustCall, mustNotCall, closeTimers } = createCallCheckCtx(done);
-  let timeout: number | Timer;
+    server.on("error", closeAndFail);
 
-  const server = createServer((socket: any) => {
-    socket.pipe(socket);
-  });
-
-  const closeAndFail = mustNotCall("no data received (timeout)", () => {
-    clearTimeout(timeout);
-    server.close();
-  });
+    //should be faster than 100ms
+    timeout = setTimeout(closeAndFail, 100);
 
-  server.on("error", mustNotCall("no data received"));
-
-  //should be faster than 100ms
-  timeout = setTimeout(() => {
-    closeAndFail();
-  }, 100);
-
-  server.listen(
-    mustCall(() => {
-      const address = server.address();
-      Bun.connect({
-        hostname: address.address,
-        port: address.port,
-        socket: {
-          data(socket, data) {
-            clearTimeout(timeout);
-            closeTimers();
-            server.close();
-            socket.end();
-            expect(data.byteLength).toBe(5);
-            expect(data.toString("utf8")).toBe("Hello");
-            done();
-          },
-          open(socket) {
-            socket.write("Hello");
+    server.listen(
+      mustCall(async () => {
+        const address = server.address() as AddressInfo;
+        client = await Bun.connect({
+          hostname: address.address,
+          port: address.port,
+          socket: {
+            drain(socket) {
+              socket.write("Hello");
+            },
+            data(socket, data) {
+              is_done = true;
+              clearTimeout(timeout);
+              server.close();
+              socket.end();
+              expect(data.byteLength).toBe(5);
+              expect(data.toString("utf8")).toBe("Hello");
+              done();
+            },
+            open(socket) {
+              socket.write("Hello");
+            },
+            connectError: closeAndFail, // connection failed
           },
-          connectError: closeAndFail, // connection failed
-        },
-      }).catch(closeAndFail);
-    }),
-  );
+        }).catch(closeAndFail);
+      }),
+    );
+  });
 });
diff --git a/test/js/node/tls/node-tls-server.test.ts b/test/js/node/tls/node-tls-server.test.ts
index a82f8cde2..6879d0927 100644
--- a/test/js/node/tls/node-tls-server.test.ts
+++ b/test/js/node/tls/node-tls-server.test.ts
@@ -455,7 +455,7 @@ describe("tls.createServer events", () => {
 
     let timeout: Timer;
     let is_done = false;
-    const server = createServer();
+    const server = createServer(COMMON_CERT);
     let maxClients = 2;
     server.maxConnections = maxClients - 1;