Deflake dgram test

test/js/bun/udp/dgram.test.ts

@@ -6,10 +6,11 @@ import { disableAggressiveGCScope } from "harness";
 import path from "path";
 
 describe("createSocket()", () => {
-  test("connect", done => {
+  test("connect", async () => {
     const PORT = 12345;
+    const { promise, resolve } = Promise.withResolvers();
     const client = createSocket("udp4");
-    client.on("close", done);
+    client.on("close", resolve);
 
     client.connect(PORT, () => {
       const remoteAddr = client.remoteAddress();
@@ -24,6 +25,8 @@ describe("createSocket()", () => {
       client.once("connect", () => client.close());
       client.connect(PORT);
     });
+
+    await promise;
   });
 
   test("IPv4 address", done => {
@@ -86,106 +89,116 @@ describe("createSocket()", () => {
   };
 
   for (const { label, data, bytes } of nodeDataCases) {
-    test(`send ${label}`, done => {
+    test(`send ${label}`, async () => {
       const client = createSocket("udp4");
       const closed = { closed: false };
+      const { promise, resolve, reject } = Promise.withResolvers();
       client.on("close", () => {
         closed.closed = true;
       });
       const server = createSocket("udp4");
-      client.on("error", err => {
-        expect(err).toBeNull();
-      });
-      server.on("error", err => {
-        expect(err).toBeNull();
-      });
       server.on("message", (data, rinfo) => {
         validateRecv(server, data, rinfo, bytes);
-
-        server.close();
-        client.close();
-        done();
+        resolve();
       });
       function sendRec() {
         if (!closed.closed) {
-          client.send(data, server.address().port, "127.0.0.1", () => {
-            setTimeout(sendRec, 100);
+          const port = server.address().port;
+          client.send(data, 0, data.length, port, "127.0.0.1", () => {
+            if (!closed.closed) {
+              setTimeout(sendRec, 10);
+            }
           });
         }
       }
-      server.on("listening", () => {
-        sendRec();
-      });
-      server.bind();
-    });
 
-    test(`send connected ${label}`, done => {
-      const client = createSocket("udp4");
-      const closed = { closed: false };
-      client.on("close", () => {
-        closed.closed = true;
-      });
-      const server = createSocket("udp4");
-      client.on("error", err => {
-        expect(err).toBeNull();
-      });
-      server.on("error", err => {
-        expect(err).toBeNull();
-      });
-      server.on("message", (data, rinfo) => {
-        validateRecv(server, data, rinfo, bytes);
-
-        server.close();
-        client.close();
-        done();
-      });
-      function sendRec() {
-        if (!closed.closed) {
-          client.send(data, () => {
-            setTimeout(sendRec, 100);
-          });
-        }
-      }
-      server.on("listening", () => {
-        const addr = server.address();
-        client.connect(addr.port, "127.0.0.1", () => {
+      try {
+        server.on("listening", () => {
           sendRec();
         });
-      });
-      server.bind();
-    });
-
-    test(`send array ${label}`, done => {
-      const client = createSocket("udp4");
-      const closed = { closed: false };
-      client.on("close", () => {
-        closed.closed = true;
-      });
-      const server = createSocket("udp4");
-      client.on("error", err => {
-        expect(err).toBeNull();
-      });
-      server.on("error", err => {
-        expect(err).toBeNull();
-      });
-      server.on("message", (data, rinfo) => {
-        validateRecv(server, data, rinfo, Buffer.from([...bytes, ...bytes, ...bytes].flat()));
-
+        server.bind();
+        await promise;
+      } finally {
+        server.close();
+        client.close();
+      }
+    });
+
+    test(`send connected ${label}`, async () => {
+      const client = createSocket("udp4");
+      const server = createSocket("udp4");
+      const closed = { closed: false };
+      const { promise, resolve, reject } = Promise.withResolvers();
+
+      try {
+        client.on("close", () => {
+          closed.closed = true;
+        });
+        server.on("message", (data, rinfo) => {
+          validateRecv(server, data, rinfo, bytes);
+          resolve();
+        });
+        function sendRec() {
+          if (!closed.closed) {
+            client.send(data, () => {
+              setTimeout(sendRec, 10);
+            });
+          }
+        }
+        server.on("listening", () => {
+          const addr = server.address();
+          client.connect(addr.port, "127.0.0.1", () => {
+            sendRec();
+          });
+        });
+        server.bind();
+
+        await promise;
+      } finally {
+        server.close();
+        client.close();
+      }
+    });
+
+    test(`send array ${label}`, async () => {
+      const client = createSocket("udp4");
+      const server = createSocket("udp4");
+      const closed = { closed: false };
+      const { promise, resolve, reject } = Promise.withResolvers();
+
+      try {
+        client.on("close", () => {
+          closed.closed = true;
+        });
+
+        client.on("error", err => {
+          expect(err).toBeNull();
+        });
+        server.on("error", err => {
+          expect(err).toBeNull();
+        });
+        server.on("message", (data, rinfo) => {
+          validateRecv(server, data, rinfo, Buffer.from([...bytes, ...bytes, ...bytes].flat()));
+
+          resolve();
+        });
+        function sendRec() {
+          if (!closed.closed) {
+            client.send([data, data, data], server.address().port, "127.0.0.1", () => {
+              setTimeout(sendRec, 10);
+            });
+          }
+        }
+        server.on("listening", () => {
+          sendRec();
+        });
+        server.bind();
+
+        await promise;
+      } finally {
         server.close();
         client.close();
-        done();
-      });
-      function sendRec() {
-        if (!closed.closed) {
-          client.send([data, data, data], server.address().port, "127.0.0.1", () => {
-            setTimeout(sendRec, 100);
-          });
-        }
       }
-      server.on("listening", () => {
-        sendRec();
-      });
-      server.bind();
     });
   }
 });

test/js/bun/udp/udp_socket.test.ts

@@ -31,10 +31,10 @@ describe("udpSocket()", () => {
     for (let i = 0; i < 30; i++) {
       const port = randomPort();
       try {
-        const socket = await udpSocket({ port });
+        using socket = await udpSocket({ port });
         expect(socket.port).toBe(port);
         expect(socket.address).toMatchObject({ port: socket.port });
-        socket.close();
+
         break;
       } catch (e) {
         continue;
@@ -43,23 +43,21 @@ describe("udpSocket()", () => {
   });
 
   test("can create a socket with a random port", async () => {
-    const socket = await udpSocket({ port: 0 });
+    using socket = await udpSocket({ port: 0 });
     expect(socket.port).toBeInteger();
     expect(socket.port).toBeWithin(1, 65535 + 1);
     expect(socket.address).toMatchObject({ port: socket.port });
-    socket.close();
   });
 
   describe.each([{ hostname: "localhost" }, { hostname: "127.0.0.1" }, { hostname: "::1" }])(
     "can create a socket with given hostname",
     ({ hostname }) => {
       test(hostname, async () => {
-        const socket = await udpSocket({ hostname });
+        using socket = await udpSocket({ hostname });
         expect(socket.hostname).toBe(hostname);
         expect(socket.port).toBeInteger();
         expect(socket.port).toBeWithin(1, 65535 + 1);
         expect(socket.address).toMatchObject({ port: socket.port });
-        socket.close();
       });
     },
   );
@@ -102,17 +100,20 @@ describe("udpSocket()", () => {
         bytes = new Uint8Array(bytes).buffer;
       }
 
-      test(`send ${label} (${binaryType || "undefined"})`, async done => {
-        const client = await udpSocket({});
-        const server = await udpSocket({
+      test(`send ${label} (${binaryType || "undefined"})`, async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+
+        using client = await udpSocket({});
+        using server = await udpSocket({
           binaryType: binaryType,
           socket: {
             data(socket, data, port, address) {
-              validateRecv(socket, data, port, address, binaryType, bytes);
-
-              server.close();
-              client.close();
-              done();
+              try {
+                validateRecv(socket, data, port, address, binaryType, bytes);
+                resolve();
+              } catch (e) {
+                reject(e);
+              }
             },
           },
         });
@@ -125,23 +126,26 @@ describe("udpSocket()", () => {
           }
         }
         sendRec();
+
+        await promise;
       });
 
-      test(`send connected ${label} (${binaryType || "undefined"})`, async done => {
-        let client;
-        const server = await udpSocket({
+      test(`send connected ${label} (${binaryType || "undefined"})`, async () => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        using server = await udpSocket({
           binaryType: binaryType,
           socket: {
             data(socket, data, port, address) {
-              validateRecv(socket, data, port, address, binaryType, bytes);
-
-              server.close();
-              client.close();
-              done();
+              try {
+                validateRecv(socket, data, port, address, binaryType, bytes);
+                resolve();
+              } catch (err) {
+                reject(err);
+              }
             },
           },
         });
-        client = await udpSocket({
+        using client = await udpSocket({
           connect: {
             port: server.port,
             hostname: "127.0.0.1",
@@ -156,22 +160,28 @@ describe("udpSocket()", () => {
           }
         }
         sendRec();
+
+        await promise;
       });
 
-      test(`sendMany ${label} (${binaryType || "undefined"})`, async done => {
-        const client = await udpSocket({});
+      test(`sendMany ${label} (${binaryType || "undefined"})`, async () => {
+        using client = await udpSocket({});
         let count = 0;
-        const server = await udpSocket({
+        let { promise, resolve, reject } = Promise.withResolvers();
+        using server = await udpSocket({
           binaryType: binaryType,
           socket: {
             data(socket, data, port, address) {
-              validateRecv(socket, data, port, address, binaryType, bytes);
+              try {
+                validateRecv(socket, data, port, address, binaryType, bytes);
+              } catch (e) {
+                reject(e);
+                return;
+              }
 
               count += 1;
               if (count === 100) {
-                server.close();
-                client.close();
-                done();
+                resolve();
               }
             },
           },
@@ -187,29 +197,34 @@ describe("udpSocket()", () => {
           }
         }
         sendRec();
+
+        await promise;
       });
 
-      test(`sendMany connected ${label} (${binaryType || "undefined"})`, async done => {
-        // const client = await udpSocket({});
-        let client;
+      test(`sendMany connected ${label} (${binaryType || "undefined"})`, async () => {
         let count = 0;
-        const server = await udpSocket({
+        let { promise, resolve, reject } = Promise.withResolvers();
+        using server = await udpSocket({
           binaryType: binaryType,
+          hostname: "127.0.0.1",
           socket: {
             data(socket, data, port, address) {
-              validateRecv(socket, data, port, address, binaryType, bytes);
+              try {
+                validateRecv(socket, data, port, address, binaryType, bytes);
+              } catch (e) {
+                reject(e);
+                return;
+              }
 
               count += 1;
               if (count === 100) {
-                server.close();
-                client.close();
-                done();
+                resolve();
               }
             },
           },
         });
 
-        client = await udpSocket({
+        using client = await udpSocket({
           connect: {
             port: server.port,
             hostname: "127.0.0.1",
@@ -226,6 +241,8 @@ describe("udpSocket()", () => {
           }
         }
         sendRec();
+
+        await promise;
       });
     }
   }