refactor: replace `deferred()` from `std/async` with `Promise.withResolvers()` (#21234)

Closes #21041

---------

Signed-off-by: Asher Gomez <ashersaupingomez@gmail.com>

1 files changed, 81 insertions, 82 deletions

diff --git a/cli/tests/unit_node/http_test.ts b/cli/tests/unit_node/http_test.ts
index 84d25e42c..ef78432cb 100644
--- a/cli/tests/unit_node/http_test.ts
+++ b/cli/tests/unit_node/http_test.ts
@@ -9,7 +9,6 @@ import {
   fail,
 } from "../../../test_util/std/testing/asserts.ts";
 import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
 
 import { gzip } from "node:zlib";
 import { Buffer } from "node:buffer";
@@ -28,42 +27,42 @@ Deno.test("[node/http listen]", async () => {
   }
 
   {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen(() => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
   }
 
   {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen().on("listening", () => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
   }
 
   for (const port of [0, -0, 0.0, "0", null, undefined]) {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer();
 
     server.listen(port, () => {
       server.close();
     });
     server.on("close", () => {
-      promise.resolve();
+      resolve();
     });
 
     await promise;
@@ -72,43 +71,43 @@ Deno.test("[node/http listen]", async () => {
 
 Deno.test("[node/http close]", async () => {
   {
-    const promise1 = deferred<void>();
-    const promise2 = deferred<void>();
+    const deferred1 = Promise.withResolvers<void>();
+    const deferred2 = Promise.withResolvers<void>();
     // Node quirk: callback gets exception object, event listener does not.
     // deno-lint-ignore no-explicit-any
     const server = http.createServer().close((err: any) => {
       assertEquals(err.code, "ERR_SERVER_NOT_RUNNING");
-      promise1.resolve();
+      deferred1.resolve();
     });
     // deno-lint-ignore no-explicit-any
     server.on("close", (err: any) => {
       assertEquals(err, undefined);
-      promise2.resolve();
+      deferred2.resolve();
     });
     server.on("listening", () => {
       throw Error("unreachable");
     });
-    await promise1;
-    await promise2;
+    await deferred1.promise;
+    await deferred2.promise;
   }
 
   {
-    const promise1 = deferred<void>();
-    const promise2 = deferred<void>();
+    const deferred1 = Promise.withResolvers<void>();
+    const deferred2 = Promise.withResolvers<void>();
     const server = http.createServer().listen().close((err) => {
       assertEquals(err, undefined);
-      promise1.resolve();
+      deferred1.resolve();
     });
     // deno-lint-ignore no-explicit-any
     server.on("close", (err: any) => {
       assertEquals(err, undefined);
-      promise2.resolve();
+      deferred2.resolve();
     });
     server.on("listening", () => {
       throw Error("unreachable");
     });
-    await promise1;
-    await promise2;
+    await deferred1.promise;
+    await deferred2.promise;
   }
 });
 
@@ -117,7 +116,7 @@ Deno.test("[node/http] chunked response", async () => {
     const body of [undefined, "", "ok"]
   ) {
     const expected = body ?? "";
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
 
     const server = http.createServer((_req, res) => {
       res.writeHead(200, { "transfer-encoding": "chunked" });
@@ -134,7 +133,7 @@ Deno.test("[node/http] chunked response", async () => {
       const actual = await res.text();
       assertEquals(actual, expected);
 
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     });
 
     await promise;
@@ -143,7 +142,7 @@ Deno.test("[node/http] chunked response", async () => {
 
 // Test empty chunks: https://github.com/denoland/deno/issues/17194
 Deno.test("[node/http] empty chunk in the middle of response", async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
 
   const server = http.createServer((_req, res) => {
     res.write("a");
@@ -159,7 +158,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
     );
     const actual = await res.text();
     assertEquals(actual, "ab");
-    server.close(() => promise.resolve());
+    server.close(() => resolve());
   });
 
   await promise;
@@ -167,7 +166,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
 
 Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => {
   for (const status of [101, 204, 205, 304]) {
-    const promise = deferred<void>();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer((_req, res) => {
       res.statusCode = status;
       res.end("");
@@ -179,15 +178,15 @@ Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async
       );
       await res.arrayBuffer();
       assertEquals(res.status, status);
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     });
     await promise;
   }
 });
 
 Deno.test("[node/http] request default protocol", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<void>();
+  const deferred1 = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
   const server = http.createServer((_, res) => {
     res.end("ok");
   });
@@ -210,22 +209,22 @@ Deno.test("[node/http] request default protocol", async () => {
         });
         clientRes = res;
         assertEquals(res.statusCode, 200);
-        promise2.resolve();
+        deferred2.resolve();
       },
     );
     clientReq.end();
   });
   server.on("close", () => {
-    promise.resolve();
+    deferred1.resolve();
   });
-  await promise;
-  await promise2;
+  await deferred1.promise;
+  await deferred2.promise;
   assert(clientReq.socket instanceof EventEmitter);
   assertEquals(clientRes!.complete, true);
 });
 
 Deno.test("[node/http] request with headers", async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((req, res) => {
     assertEquals(req.headers["x-foo"], "bar");
     res.end("ok");
@@ -249,7 +248,7 @@ Deno.test("[node/http] request with headers", async () => {
     req.end();
   });
   server.on("close", () => {
-    promise.resolve();
+    resolve();
   });
   await promise;
 });
@@ -258,7 +257,7 @@ Deno.test("[node/http] non-string buffer response", {
   // TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case.
   sanitizeResources: false,
 }, async () => {
-  const promise = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((_, res) => {
     res.socket!.end();
     gzip(
@@ -281,7 +280,7 @@ Deno.test("[node/http] non-string buffer response", {
     } catch (e) {
       server.emit("error", e);
     } finally {
-      server.close(() => promise.resolve());
+      server.close(() => resolve());
     }
   });
   await promise;
@@ -461,7 +460,7 @@ Deno.test("[node/http] send request with chunked body as default", async () => {
 });
 
 Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
-  const d = deferred<void>();
+  const { promise, resolve } = Promise.withResolvers<void>();
   const server = http.createServer((_req, res) => {
     const writeHeadSpy = spy(res, "writeHead");
     // deno-lint-ignore no-explicit-any
@@ -476,11 +475,11 @@ Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
     const res = await fetch(`http://localhost:${port}`);
     assertEquals(await res.text(), "Hello World");
     server.close(() => {
-      d.resolve();
+      resolve();
     });
   });
 
-  await d;
+  await promise;
 });
 
 Deno.test("[node/http] server unref", async () => {
@@ -504,7 +503,7 @@ Deno.test("[node/http] server unref", async () => {
 Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
   // deno-lint-ignore no-explicit-any
   let headers: any;
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "POST",
     headers: { 1: 2 },
@@ -514,18 +513,18 @@ Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
     resp.on("data", () => {});
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(headers!["1"], "2");
 });
 
 Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = https.request("https://localhost:5545/http_version", {
     method: "POST",
     headers: { 1: 2 },
@@ -535,39 +534,39 @@ Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "HTTP/1.1");
 });
 
 Deno.test("[node/http] ClientRequest setTimeout", async () => {
   let body = "";
-  const def = deferred();
-  const timer = setTimeout(() => def.reject("timed out"), 50000);
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
+  const timer = setTimeout(() => reject("timed out"), 50000);
   const req = http.request("http://localhost:4545/http_version", (resp) => {
     resp.on("data", (chunk) => {
       body += chunk;
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.setTimeout(120000);
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   clearTimeout(timer);
   assertEquals(body, "HTTP/1.1");
 });
 
 Deno.test("[node/http] ClientRequest PATCH", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "PATCH",
   }, (resp) => {
@@ -576,20 +575,20 @@ Deno.test("[node/http] ClientRequest PATCH", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.write("hello ");
   req.write("world");
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "hello world");
 });
 
 Deno.test("[node/http] ClientRequest PUT", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request("http://localhost:4545/echo_server", {
     method: "PUT",
   }, (resp) => {
@@ -598,20 +597,20 @@ Deno.test("[node/http] ClientRequest PUT", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
   req.write("hello ");
   req.write("world");
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "hello world");
 });
 
 Deno.test("[node/http] ClientRequest search params", async () => {
   let body = "";
-  const def = deferred();
+  const { promise, resolve, reject } = Promise.withResolvers<void>();
   const req = http.request({
     host: "localhost:4545",
     path: "search_params?foo=bar",
@@ -621,18 +620,18 @@ Deno.test("[node/http] ClientRequest search params", async () => {
     });
 
     resp.on("end", () => {
-      def.resolve();
+      resolve();
     });
   });
-  req.once("error", (e) => def.reject(e));
+  req.once("error", (e) => reject(e));
   req.end();
-  await def;
+  await promise;
   assertEquals(body, "foo=bar");
 });
 
 Deno.test("[node/http] HTTPS server", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<void>();
+  const deferred = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<void>();
   const client = Deno.createHttpClient({
     caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")],
   });
@@ -652,14 +651,14 @@ Deno.test("[node/http] HTTPS server", async () => {
       assertEquals(res.status, 200);
       assertEquals(await res.text(), "success!");
       server.close();
-      promise2.resolve();
+      deferred2.resolve();
     });
   })
     .on("error", () => fail());
   server.on("close", () => {
-    promise.resolve();
+    deferred.resolve();
   });
-  await Promise.all([promise, promise2]);
+  await Promise.all([deferred.promise, deferred2.promise]);
   client.close();
 });
 
@@ -667,7 +666,7 @@ Deno.test(
   "[node/http] client upgrade",
   { permissions: { net: true } },
   async () => {
-    const promise = deferred();
+    const { promise, resolve } = Promise.withResolvers<void>();
     const server = http.createServer((req, res) => {
       // @ts-ignore: It exists on TLSSocket
       assert(!req.socket.encrypted);
@@ -706,7 +705,7 @@ Deno.test(
         // @ts-ignore it's a socket for real
         serverSocket!.end();
         server.close(() => {
-          promise.resolve();
+          resolve();
         });
       });
     });
@@ -725,7 +724,7 @@ Deno.test(
       received = true;
       return new Response("hello");
     });
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
     let body = "";
 
     const request = http.request(
@@ -736,11 +735,11 @@ Deno.test(
         });
 
         resp.on("end", () => {
-          promise.resolve();
+          resolve();
         });
       },
     );
-    request.on("error", promise.reject);
+    request.on("error", reject);
     request.end(() => {
       assert(received);
     });
@@ -754,22 +753,22 @@ Deno.test(
 );
 
 Deno.test("[node/http] server emits error if addr in use", async () => {
-  const promise = deferred<void>();
-  const promise2 = deferred<Error>();
+  const deferred1 = Promise.withResolvers<void>();
+  const deferred2 = Promise.withResolvers<Error>();
 
   const server = http.createServer();
   server.listen(9001);
 
   const server2 = http.createServer();
   server2.on("error", (e) => {
-    promise2.resolve(e);
+    deferred2.resolve(e);
   });
   server2.listen(9001);
 
-  const err = await promise2;
-  server.close(() => promise.resolve());
+  const err = await deferred2.promise;
+  server.close(() => deferred1.resolve());
   server2.close();
-  await promise;
+  await deferred1.promise;
   const expectedMsg = Deno.build.os === "windows"
     ? "Only one usage of each socket address"
     : "Address already in use";
@@ -795,15 +794,15 @@ Deno.test(
         return new Response("hello");
       },
     );
-    const promise = deferred();
+    const { promise, resolve, reject } = Promise.withResolvers<void>();
 
     const request = http.request("http://localhost:5929/");
-    request.on("error", promise.reject);
+    request.on("error", reject);
     request.on("close", () => {});
     request.end();
     setTimeout(() => {
       request.destroy(new Error());
-      promise.resolve();
+      resolve();
     }, 100);
 
     await promise;