2 files changed, 65 insertions, 71 deletions

diff --git a/cli/tests/unit/websocket_test.ts b/cli/tests/unit/websocket_test.ts
index ac33f9d69..11f0fd7dc 100644
--- a/cli/tests/unit/websocket_test.ts
+++ b/cli/tests/unit/websocket_test.ts
@@ -7,6 +7,9 @@ import {
   fail,
 } from "./test_util.ts";
 
+const servePort = 4248;
+const serveUrl = `ws://localhost:${servePort}/`;
+
 Deno.test({ permissions: "none" }, function websocketPermissionless() {
   assertThrows(
     () => new WebSocket("ws://localhost"),
@@ -81,13 +84,13 @@ Deno.test(
       signal: ac.signal,
       onListen: () => listeningPromise.resolve(),
       hostname: "localhost",
-      port: 4246,
+      port: servePort,
     });
 
     await listeningPromise;
     const promise = deferred();
-    const ws = new WebSocket("ws://localhost:4246/");
-    assertEquals(ws.url, "ws://localhost:4246/");
+    const ws = new WebSocket(serveUrl);
+    assertEquals(ws.url, serveUrl);
     ws.onerror = () => fail();
     ws.onmessage = (e) => {
       assertEquals(e.data, "Hello");
@@ -133,13 +136,13 @@ Deno.test({
     signal: ac.signal,
     onListen: () => listeningPromise.resolve(),
     hostname: "localhost",
-    port: 4247,
+    port: servePort,
   });
 
   await listeningPromise;
 
-  const ws = new WebSocket("ws://localhost:4247/");
-  assertEquals(ws.url, "ws://localhost:4247/");
+  const ws = new WebSocket(serveUrl);
+  assertEquals(ws.url, serveUrl);
   ws.onerror = () => fail();
   ws.onmessage = () => ws.send("bye");
   ws.onclose = () => {
@@ -173,13 +176,13 @@ Deno.test({
     signal: ac.signal,
     onListen: () => listeningPromise.resolve(),
     hostname: "localhost",
-    port: 4247,
+    port: servePort,
   });
 
   await listeningPromise;
 
-  const ws = new WebSocket("ws://localhost:4247/");
-  assertEquals(ws.url, "ws://localhost:4247/");
+  const ws = new WebSocket(serveUrl);
+  assertEquals(ws.url, serveUrl);
   let seenBye = false;
   ws.onerror = () => fail();
   ws.onmessage = ({ data }) => {
diff --git a/cli/tests/unit_node/http2_test.ts b/cli/tests/unit_node/http2_test.ts
index 64824f3e8..8e7b261ae 100644
--- a/cli/tests/unit_node/http2_test.ts
+++ b/cli/tests/unit_node/http2_test.ts
@@ -5,75 +5,66 @@ import * as net from "node:net";
 import { deferred } from "../../../test_util/std/async/deferred.ts";
 import { assertEquals } from "../../../test_util/std/testing/asserts.ts";
 
-const {
-  HTTP2_HEADER_AUTHORITY,
-  HTTP2_HEADER_METHOD,
-  HTTP2_HEADER_PATH,
-  HTTP2_HEADER_STATUS,
-} = http2.constants;
-
-Deno.test("[node/http2 client]", async () => {
-  // Create a server to respond to the HTTP2 requests
-  const portPromise = deferred();
-  const reqPromise = deferred<Request>();
-  const ready = deferred();
-  const ac = new AbortController();
-  const server = Deno.serve({
-    port: 0,
-    signal: ac.signal,
-    onListen: ({ port }: { port: number }) => portPromise.resolve(port),
-    handler: async (req: Request) => {
-      reqPromise.resolve(req);
-      await ready;
-      return new Response("body", {
-        status: 401,
-        headers: { "resp-header-name": "resp-header-value" },
-      });
-    },
-  });
+for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
+  Deno.test(`[node/http2 client] ${url}`, {
+    ignore: Deno.build.os === "windows",
+  }, async () => {
+    // Create a server to respond to the HTTP2 requests
+    const client = http2.connect(url, {});
+    client.on("error", (err) => console.error(err));
 
-  const port = await portPromise;
+    const req = client.request({ ":method": "POST", ":path": "/" }, {
+      waitForTrailers: true,
+    });
 
-  // Get a session
-  const sessionPromise = deferred();
-  const session = http2.connect(
-    `localhost:${port}`,
-    {},
-    sessionPromise.resolve.bind(sessionPromise),
-  );
-  const session2 = await sessionPromise;
-  assertEquals(session, session2);
-
-  // Write a request, including a body
-  const stream = session.request({
-    [HTTP2_HEADER_AUTHORITY]: `localhost:${port}`,
-    [HTTP2_HEADER_METHOD]: "POST",
-    [HTTP2_HEADER_PATH]: "/path",
-    "req-header-name": "req-header-value",
-  });
-  stream.write("body");
-  stream.end();
+    let receivedTrailers;
+    let receivedHeaders;
+    let receivedData = "";
 
-  // Check the request
-  const req = await reqPromise;
-  assertEquals(req.headers.get("req-header-name"), "req-header-value");
-  assertEquals(await req.text(), "body");
+    req.on("response", (headers, _flags) => {
+      receivedHeaders = headers;
+    });
 
-  ready.resolve();
+    req.write("hello");
+    req.setEncoding("utf8");
 
-  // Read a response
-  const headerPromise = new Promise<Record<string, string | string[]>>((
-    resolve,
-  ) => stream.on("headers", resolve));
-  const headers = await headerPromise;
-  assertEquals(headers["resp-header-name"], "resp-header-value");
-  assertEquals(headers[HTTP2_HEADER_STATUS], "401");
+    req.on("wantTrailers", () => {
+      req.sendTrailers({ foo: "bar" });
+    });
 
-  ac.abort();
-  await server.finished;
-});
+    req.on("trailers", (trailers, _flags) => {
+      receivedTrailers = trailers;
+    });
+
+    req.on("data", (chunk) => {
+      receivedData += chunk;
+    });
+    req.end();
+
+    const endPromise = deferred();
+    setTimeout(() => {
+      try {
+        client.close();
+      } catch (_) {
+        // pass
+      }
+      endPromise.resolve();
+    }, 2000);
+
+    await endPromise;
+    assertEquals(receivedHeaders, { ":status": 200 });
+    assertEquals(receivedData, "hello world\n");
+
+    assertEquals(receivedTrailers, {
+      "abc": "def",
+      "opr": "stv",
+      "foo": "bar",
+    });
+  });
+}
 
-Deno.test("[node/http2 server]", async () => {
+// TODO(bartlomieju): reenable sanitizers
+Deno.test("[node/http2 server]", { sanitizeOps: false }, async () => {
   const server = http2.createServer();
   server.listen(0);
   const port = (<net.AddressInfo> server.address()).port;