From 68b388a93a3efe443fc5e306e883847bfb8551db Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Mon, 14 Oct 2024 14:00:02 +0530
Subject: fix(ext/node): allow writing to tty columns (#26201)

Behave similar to Node.js where modifying `stdout.columns` doesn't
really resize the terminal. Ref
https://github.com/nodejs/node/issues/17529

Fixes https://github.com/denoland/deno/issues/26196
---
 tests/unit_node/process_test.ts | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/process_test.ts b/tests/unit_node/process_test.ts
index 0e0f169d6..9506fb609 100644
--- a/tests/unit_node/process_test.ts
+++ b/tests/unit_node/process_test.ts
@@ -1175,3 +1175,8 @@ Deno.test("process.cpuUsage()", () => {
   assert(typeof cpuUsage.user === "number");
   assert(typeof cpuUsage.system === "number");
 });
+
+Deno.test("process.stdout.columns writable", () => {
+  process.stdout.columns = 80;
+  assertEquals(process.stdout.columns, 80);
+});
-- 
cgit v1.2.3


From bbad7c592282dace88c77b0e089d53cb32878673 Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Mon, 14 Oct 2024 14:24:26 +0530
Subject: fix(ext/node): compute pem length (upper bound) for key exports
 (#26231)

Fixes https://github.com/denoland/deno/issues/26188
---
 tests/unit_node/crypto/crypto_key_test.ts | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/crypto/crypto_key_test.ts b/tests/unit_node/crypto/crypto_key_test.ts
index 7995ce5d3..3c7ad4423 100644
--- a/tests/unit_node/crypto/crypto_key_test.ts
+++ b/tests/unit_node/crypto/crypto_key_test.ts
@@ -656,3 +656,24 @@ z6TExWlQMjt66nV7R8cRAkzmABrG+NW3e8Zpac7Lkuv+zu0S+K7c
   assertEquals(publicKey.type, "public");
   assertEquals(publicKey.asymmetricKeyType, "rsa");
 });
+
+// https://github.com/denoland/deno/issues/26188
+Deno.test("generateKeyPair large pem", function () {
+  const passphrase = "mypassphrase";
+  const cipher = "aes-256-cbc";
+  const modulusLength = 4096;
+
+  generateKeyPairSync("rsa", {
+    modulusLength,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem",
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem",
+      cipher,
+      passphrase,
+    },
+  });
+});
-- 
cgit v1.2.3


From 21fa953f320c66a897822c4c731b2fae5f07c78b Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Wed, 16 Oct 2024 14:27:28 +0530
Subject: fix(ext/node): timingSafeEqual account for AB byteOffset (#26292)

Fixes https://github.com/denoland/deno/issues/26276
---
 tests/unit_node/crypto/crypto_misc_test.ts | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/crypto/crypto_misc_test.ts b/tests/unit_node/crypto/crypto_misc_test.ts
index 47a48b1bf..007009339 100644
--- a/tests/unit_node/crypto/crypto_misc_test.ts
+++ b/tests/unit_node/crypto/crypto_misc_test.ts
@@ -1,5 +1,6 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-import { randomFillSync, randomUUID } from "node:crypto";
+import { randomFillSync, randomUUID, timingSafeEqual } from "node:crypto";
+import { Buffer } from "node:buffer";
 import { assert, assertEquals } from "../../unit/test_util.ts";
 import { assertNotEquals } from "@std/assert";
 
@@ -28,3 +29,10 @@ Deno.test("[node/crypto.randomFillSync] array buffer view", () => {
   assertEquals(buf.subarray(0, 8), new Uint8Array(8));
   assertEquals(buf.subarray(24, 32), new Uint8Array(8));
 });
+
+Deno.test("[node/crypto.timingSafeEqual] compares equal Buffer with different byteOffset", () => {
+  const a = Buffer.from([212, 213]);
+  const b = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 212, 213]).subarray(8);
+
+  assert(timingSafeEqual(a, b));
+});
-- 
cgit v1.2.3


From d59599fc187c559ee231882773e1c5a2b932fc3d Mon Sep 17 00:00:00 2001
From: Yoshiya Hinosawa <stibium121@gmail.com>
Date: Wed, 16 Oct 2024 20:58:44 +0900
Subject: fix(ext/node): fix dns.lookup result ordering (#26264)

partially unblocks #25470

This PR aligns the resolution of `localhost` hostname to Node.js
behavior.

In Node.js `dns.lookup("localhost", (_, addr) => console.log(addr))`
prints ipv6 address `::1`, but it prints ipv4 address `127.0.0.1` in
Deno. That difference causes some errors in the work of enabling
`createConnection` option in `http.request` (#25470). This PR fixes the
issue by aligning `dns.lookup` behavior to Node.js.

This PR also changes the following behaviors (resolving TODOs):
- `http.createServer` now listens on ipv6 address `[::]` by default on
linux/mac
- `net.createServer` now listens on ipv6 address `[::]` by default on
linux/mac

These changes are also alignments to Node.js behaviors.
---
 tests/unit_node/http_test.ts |  8 ++++++--
 tests/unit_node/tls_test.ts  | 12 +++++++++---
 2 files changed, 15 insertions(+), 5 deletions(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts
index f85b1466b..f1ff77bb3 100644
--- a/tests/unit_node/http_test.ts
+++ b/tests/unit_node/http_test.ts
@@ -318,10 +318,14 @@ Deno.test("[node/http] IncomingRequest socket has remoteAddress + remotePort", a
     // deno-lint-ignore no-explicit-any
     const port = (server.address() as any).port;
     const res = await fetch(
-      `http://127.0.0.1:${port}/`,
+      `http://localhost:${port}/`,
     );
     await res.arrayBuffer();
-    assertEquals(remoteAddress, "127.0.0.1");
+    if (Deno.build.os === "windows") {
+      assertEquals(remoteAddress, "127.0.0.1");
+    } else {
+      assertEquals(remoteAddress, "::1");
+    }
     assertEquals(typeof remotePort, "number");
     server.close(() => resolve());
   });
diff --git a/tests/unit_node/tls_test.ts b/tests/unit_node/tls_test.ts
index 93eacd5ec..847ec2dde 100644
--- a/tests/unit_node/tls_test.ts
+++ b/tests/unit_node/tls_test.ts
@@ -32,13 +32,15 @@ for (
 ) {
   Deno.test(`tls.connect sends correct ALPN: '${alpnServer}' + '${alpnClient}' = '${expected}'`, async () => {
     const listener = Deno.listenTls({
+      hostname: "localhost",
       port: 0,
       key,
       cert,
       alpnProtocols: alpnServer,
     });
     const outgoing = tls.connect({
-      host: "localhost",
+      host: "::1",
+      servername: "localhost",
       port: listener.addr.port,
       ALPNProtocols: alpnClient,
       secureContext: {
@@ -61,6 +63,7 @@ Deno.test("tls.connect makes tls connection", async () => {
   const ctl = new AbortController();
   let port;
   const serve = Deno.serve({
+    hostname: "localhost",
     port: 0,
     key,
     cert,
@@ -71,7 +74,8 @@ Deno.test("tls.connect makes tls connection", async () => {
   await delay(200);
 
   const conn = tls.connect({
-    host: "localhost",
+    host: "::1",
+    servername: "localhost",
     port,
     secureContext: {
       ca: rootCaCert,
@@ -102,6 +106,7 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
   const { promise, resolve } = Promise.withResolvers<void>();
   const ctl = new AbortController();
   const serve = Deno.serve({
+    hostname: "localhost",
     port: 8443,
     key,
     cert,
@@ -111,7 +116,8 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
   await delay(200);
 
   const conn = tls.connect({
-    host: "localhost",
+    host: "::1",
+    servername: "localhost",
     port: 8443,
     secureContext: {
       ca: rootCaCert,
-- 
cgit v1.2.3


From f7dba52133904a9e4ca0468e2c98894992ea2e42 Mon Sep 17 00:00:00 2001
From: Nathan Whitaker <17734409+nathanwhit@users.noreply.github.com>
Date: Wed, 16 Oct 2024 11:25:25 -0700
Subject: fix(child_process): map node `--no-warnings` flag to `--quiet`
 (#26288)

Closes https://github.com/denoland/deno/issues/25899
---
 tests/unit_node/child_process_test.ts | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/child_process_test.ts b/tests/unit_node/child_process_test.ts
index f776fa4ac..0ea3c46cf 100644
--- a/tests/unit_node/child_process_test.ts
+++ b/tests/unit_node/child_process_test.ts
@@ -1045,3 +1045,19 @@ Deno.test(async function sendAfterClosedThrows() {
 
   await timeout.promise;
 });
+
+Deno.test(async function noWarningsFlag() {
+  const code = ``;
+  const file = await Deno.makeTempFile();
+  await Deno.writeTextFile(file, code);
+  const timeout = withTimeout<void>();
+  const child = CP.fork(file, [], {
+    execArgv: ["--no-warnings"],
+    stdio: ["inherit", "inherit", "inherit", "ipc"],
+  });
+  child.on("close", () => {
+    timeout.resolve();
+  });
+
+  await timeout.promise;
+});
-- 
cgit v1.2.3


From 458d6278d2835896018086da773fd72b7af8ed66 Mon Sep 17 00:00:00 2001
From: Nathan Whitaker <17734409+nathanwhit@users.noreply.github.com>
Date: Wed, 16 Oct 2024 17:42:15 -0700
Subject: fix(node/http): normalize header names in `ServerResponse` (#26339)

Fixes https://github.com/denoland/deno/issues/26115.

We weren't normalizing the headers to lower case, so code that attempted
to delete the `Content-Length` header (but used a different case) wasn't
actually removing the header.
---
 tests/unit_node/http_test.ts | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts
index f1ff77bb3..0faf7fb34 100644
--- a/tests/unit_node/http_test.ts
+++ b/tests/unit_node/http_test.ts
@@ -1147,6 +1147,34 @@ Deno.test("[node/http] ServerResponse appendHeader set-cookie", async () => {
   await promise;
 });
 
+Deno.test("[node/http] ServerResponse header names case insensitive", async () => {
+  const { promise, resolve } = Promise.withResolvers<void>();
+  const server = http.createServer((_req, res) => {
+    res.setHeader("Content-Length", "12345");
+    res.removeHeader("content-length");
+    assertEquals(res.getHeader("Content-Length"), undefined);
+    assert(!res.hasHeader("Content-Length"));
+    res.appendHeader("content-length", "12345");
+    res.removeHeader("Content-Length");
+    assertEquals(res.getHeader("content-length"), undefined);
+    assert(!res.hasHeader("content-length"));
+    res.end("Hello World");
+  });
+
+  server.listen(async () => {
+    const { port } = server.address() as { port: number };
+    const res = await fetch(`http://localhost:${port}`);
+    assertEquals(res.headers.get("Content-Length"), null);
+    assertEquals(res.headers.get("content-length"), null);
+    assertEquals(await res.text(), "Hello World");
+    server.close(() => {
+      resolve();
+    });
+  });
+
+  await promise;
+});
+
 Deno.test("[node/http] IncomingMessage override", () => {
   const req = new http.IncomingMessage(new net.Socket());
   // https://github.com/dougmoscrop/serverless-http/blob/3aaa6d0fe241109a8752efb011c242d249f32368/lib/request.js#L20-L30
-- 
cgit v1.2.3


From 167f674c7cbb9632000c1feb0b747ba098b01c12 Mon Sep 17 00:00:00 2001
From: Nathan Whitaker <17734409+nathanwhit@users.noreply.github.com>
Date: Wed, 16 Oct 2024 19:58:11 -0700
Subject: fix: don't warn on ignored signals on windows (#26332)

Closes #26183.

The warnings are super noisy and not actionable for the user
---
 tests/unit_node/process_test.ts | 28 ----------------------------
 1 file changed, 28 deletions(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/process_test.ts b/tests/unit_node/process_test.ts
index 9506fb609..f9138c8f0 100644
--- a/tests/unit_node/process_test.ts
+++ b/tests/unit_node/process_test.ts
@@ -25,7 +25,6 @@ import {
   assertThrows,
   fail,
 } from "@std/assert";
-import { assertSpyCall, assertSpyCalls, spy } from "@std/testing/mock";
 import { stripAnsiCode } from "@std/fmt/colors";
 import * as path from "@std/path";
 import { delay } from "@std/async/delay";
@@ -239,33 +238,6 @@ Deno.test({
   },
 });
 
-Deno.test({
-  name: "process.on - ignored signals on windows",
-  ignore: Deno.build.os !== "windows",
-  fn() {
-    const ignoredSignals = ["SIGHUP", "SIGUSR1", "SIGUSR2"];
-
-    for (const signal of ignoredSignals) {
-      using consoleSpy = spy(console, "warn");
-      const handler = () => {};
-      process.on(signal, handler);
-      process.off(signal, handler);
-      assertSpyCall(consoleSpy, 0, {
-        args: [`Ignoring signal "${signal}" on Windows`],
-      });
-    }
-
-    {
-      using consoleSpy = spy(console, "warn");
-      const handler = () => {};
-      process.on("SIGTERM", handler);
-      process.off("SIGTERM", handler);
-      // No warning is made for SIGTERM
-      assertSpyCalls(consoleSpy, 0);
-    }
-  },
-});
-
 Deno.test(
   { permissions: { run: true, read: true } },
   async function processKill() {
-- 
cgit v1.2.3


From 9fde5cb5e045551fe344b3f60370744eea30ccb4 Mon Sep 17 00:00:00 2001
From: Nathan Whitaker <17734409+nathanwhit@users.noreply.github.com>
Date: Thu, 17 Oct 2024 12:51:15 -0700
Subject: fix(node/fs): copyFile with `COPYFILE_EXCL` should not throw if the
 destination doesn't exist (#26360)

Fixes #26313.

We were checking for the NotFound error, but still calling the callback
with the error / throwing.
---
 tests/unit_node/fs_test.ts | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/fs_test.ts b/tests/unit_node/fs_test.ts
index 2d1465aec..17da45dcf 100644
--- a/tests/unit_node/fs_test.ts
+++ b/tests/unit_node/fs_test.ts
@@ -1,11 +1,13 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 
-import { assert, assertEquals, assertThrows } from "@std/assert";
+/// <reference lib="deno.ns" />
+import { assert, assertEquals, assertRejects, assertThrows } from "@std/assert";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   closeSync,
   constants,
+  copyFileSync,
   createWriteStream,
   existsSync,
   lstatSync,
@@ -20,6 +22,7 @@ import {
 } from "node:fs";
 import {
   constants as fsPromiseConstants,
+  copyFile,
   cp,
   FileHandle,
   open,
@@ -212,3 +215,19 @@ Deno.test("[node/fs] readSync works", () => {
   assertEquals(bytesRead, 12);
   closeSync(fd!);
 });
+
+Deno.test("[node/fs] copyFile COPYFILE_EXCL works", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "foo-"));
+  const src = join(dir, "src.txt");
+  const dest = join(dir, "dest.txt");
+  await writeFile(src, "");
+  await copyFile(src, dest, fsPromiseConstants.COPYFILE_EXCL);
+  assert(existsSync(dest));
+  assertRejects(() => copyFile(src, dest, fsPromiseConstants.COPYFILE_EXCL));
+  const dest2 = join(dir, "dest2.txt");
+  copyFileSync(src, dest2, fsPromiseConstants.COPYFILE_EXCL);
+  assert(existsSync(dest2));
+  assertThrows(() =>
+    copyFileSync(src, dest2, fsPromiseConstants.COPYFILE_EXCL)
+  );
+});
-- 
cgit v1.2.3


From 2435a361c64fc9bac4aee7b268b4c0a42eee4471 Mon Sep 17 00:00:00 2001
From: Nathan Whitaker <17734409+nathanwhit@users.noreply.github.com>
Date: Thu, 17 Oct 2024 15:19:37 -0700
Subject: chore: fix flaky COPYFILE_EXCL test (#26370)

It was missing an await
---
 tests/unit_node/fs_test.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/fs_test.ts b/tests/unit_node/fs_test.ts
index 17da45dcf..ac9c4a53e 100644
--- a/tests/unit_node/fs_test.ts
+++ b/tests/unit_node/fs_test.ts
@@ -223,7 +223,9 @@ Deno.test("[node/fs] copyFile COPYFILE_EXCL works", async () => {
   await writeFile(src, "");
   await copyFile(src, dest, fsPromiseConstants.COPYFILE_EXCL);
   assert(existsSync(dest));
-  assertRejects(() => copyFile(src, dest, fsPromiseConstants.COPYFILE_EXCL));
+  await assertRejects(() =>
+    copyFile(src, dest, fsPromiseConstants.COPYFILE_EXCL)
+  );
   const dest2 = join(dir, "dest2.txt");
   copyFileSync(src, dest2, fsPromiseConstants.COPYFILE_EXCL);
   assert(existsSync(dest2));
-- 
cgit v1.2.3


From 285635daa67274f961d29c1e7795222709dc9618 Mon Sep 17 00:00:00 2001
From: Yoshiya Hinosawa <stibium121@gmail.com>
Date: Wed, 23 Oct 2024 11:28:04 +0900
Subject: fix(ext/node): map `ERROR_INVALID_NAME` to `ENOENT` on windows
 (#26475)

In libuv on windows, `ERROR_INVALID_NAME` is mapped to `ENOENT`, but it
is mapped to `EINVAL` in our compat implementation, which causes the
issue #24899.

ref:
https://github.com/libuv/libuv/blob/d4ab6fbba4669935a6bc23645372dfe4ac29ab39/src/win/error.c#L138

closes #24899
closes #26411
closes #23635
closes #21165
closes #19067
---
 tests/unit_node/fs_test.ts | 11 +++++++++++
 1 file changed, 11 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/fs_test.ts b/tests/unit_node/fs_test.ts
index ac9c4a53e..ef8f829cd 100644
--- a/tests/unit_node/fs_test.ts
+++ b/tests/unit_node/fs_test.ts
@@ -233,3 +233,14 @@ Deno.test("[node/fs] copyFile COPYFILE_EXCL works", async () => {
     copyFileSync(src, dest2, fsPromiseConstants.COPYFILE_EXCL)
   );
 });
+
+Deno.test("[node/fs] statSync throws ENOENT for invalid path containing colon in it", () => {
+  // deno-lint-ignore no-explicit-any
+  const err: any = assertThrows(() => {
+    // Note: Deno.stat throws ERROR_INVALID_NAME (os error 123) instead of
+    // ERROR_FILE_NOT_FOUND (os error 2) on windows. This case checks that
+    // ERROR_INVALID_NAME is mapped to ENOENT correctly on node compat layer.
+    statSync("jsr:@std/assert");
+  });
+  assertEquals(err.code, "ENOENT");
+});
-- 
cgit v1.2.3


From 92ed4d38dbef98b9353d6dd6d96abb400be56f9f Mon Sep 17 00:00:00 2001
From: Satya Rohith <me@satyarohith.com>
Date: Wed, 23 Oct 2024 13:17:43 +0530
Subject: fix(node:tls): set TLSSocket.alpnProtocol for client connections
 (#26476)

Towards https://github.com/denoland/deno/issues/26127
---
 tests/unit_node/tls_test.ts | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/tls_test.ts b/tests/unit_node/tls_test.ts
index 847ec2dde..236dab208 100644
--- a/tests/unit_node/tls_test.ts
+++ b/tests/unit_node/tls_test.ts
@@ -235,3 +235,31 @@ Deno.test("tls.rootCertificates is not empty", () => {
     (tls.rootCertificates as string[]).push("new cert");
   }, TypeError);
 });
+
+Deno.test("TLSSocket.alpnProtocol is set for client", async () => {
+  const listener = Deno.listenTls({
+    hostname: "localhost",
+    port: 0,
+    key,
+    cert,
+    alpnProtocols: ["a"],
+  });
+  const outgoing = tls.connect({
+    host: "::1",
+    servername: "localhost",
+    port: listener.addr.port,
+    ALPNProtocols: ["a"],
+    secureContext: {
+      ca: rootCaCert,
+      // deno-lint-ignore no-explicit-any
+    } as any,
+  });
+
+  const conn = await listener.accept();
+  const handshake = await conn.handshake();
+  assertEquals(handshake.alpnProtocol, "a");
+  conn.close();
+  outgoing.destroy();
+  listener.close();
+  await new Promise((resolve) => outgoing.on("close", resolve));
+});
-- 
cgit v1.2.3


From ef53ce3ac40e2c545397669e61e4e92423555d94 Mon Sep 17 00:00:00 2001
From: Marvin Hagemeister <marvin@deno.com>
Date: Thu, 24 Oct 2024 11:46:51 +0200
Subject: fix(node/util): support array formats in `styleText` (#26507)

We missed adding support for an array of formats being passed to
`util.styleText`.

Fixes https://github.com/denoland/deno/issues/26496
---
 tests/unit_node/util_test.ts | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/util_test.ts b/tests/unit_node/util_test.ts
index a47c231a1..6267018b1 100644
--- a/tests/unit_node/util_test.ts
+++ b/tests/unit_node/util_test.ts
@@ -353,3 +353,8 @@ Deno.test("[util] styleText()", () => {
   const redText = util.styleText("red", "error");
   assertEquals(redText, "\x1B[31merror\x1B[39m");
 });
+
+Deno.test("[util] styleText() with array of formats", () => {
+  const colored = util.styleText(["red", "green"], "error");
+  assertEquals(colored, "\x1b[32m\x1b[31merror\x1b[39m\x1b[39m");
+});
-- 
cgit v1.2.3


From 8dd6177c624649d75ffcacca77e7c4f48cea07a2 Mon Sep 17 00:00:00 2001
From: Nicola Bovolato <61934734+nicolabovolato@users.noreply.github.com>
Date: Fri, 25 Oct 2024 00:02:26 +0200
Subject: fix(ext/node): refactor http.ServerResponse into function class
 (#26210)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

While testing, I found out that light-my-request relies on
`ServerResponse.connection`, which is deprecated, so I added that and
`socket`, the non deprecated property.

It also relies on an undocumented `_header` property, apparently for
[raw header
processing](https://github.com/fastify/light-my-request/blob/v6.1.0/lib/response.js#L180-L186).
I added it as an empty string, feel free to provide other approaches.

Fixes #19901

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
---
 tests/unit_node/http_test.ts | 80 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 78 insertions(+), 2 deletions(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts
index 0faf7fb34..84d6f5727 100644
--- a/tests/unit_node/http_test.ts
+++ b/tests/unit_node/http_test.ts
@@ -3,10 +3,14 @@
 // deno-lint-ignore-file no-console
 
 import EventEmitter from "node:events";
-import http, { type RequestOptions, type ServerResponse } from "node:http";
+import http, {
+  IncomingMessage,
+  type RequestOptions,
+  ServerResponse,
+} from "node:http";
 import url from "node:url";
 import https from "node:https";
-import net from "node:net";
+import net, { Socket } from "node:net";
 import fs from "node:fs";
 import { text } from "node:stream/consumers";
 
@@ -1704,3 +1708,75 @@ Deno.test("[node/http] upgraded socket closes when the server closed without clo
   await clientSocketClosed.promise;
   await serverProcessClosed.promise;
 });
+
+// deno-lint-ignore require-await
+Deno.test("[node/http] ServerResponse.call()", async () => {
+  function Wrapper(this: unknown, req: IncomingMessage) {
+    ServerResponse.call(this, req);
+  }
+  Object.setPrototypeOf(Wrapper.prototype, ServerResponse.prototype);
+
+  // deno-lint-ignore no-explicit-any
+  const wrapper = new (Wrapper as any)(new IncomingMessage(new Socket()));
+
+  assert(wrapper instanceof ServerResponse);
+});
+
+Deno.test("[node/http] ServerResponse _header", async () => {
+  const { promise, resolve } = Promise.withResolvers<void>();
+  const server = http.createServer((_req, res) => {
+    assert(Object.hasOwn(res, "_header"));
+    res.end();
+  });
+
+  server.listen(async () => {
+    const { port } = server.address() as { port: number };
+    const res = await fetch(`http://localhost:${port}`);
+    await res.body?.cancel();
+    server.close(() => {
+      resolve();
+    });
+  });
+
+  await promise;
+});
+
+Deno.test("[node/http] ServerResponse connection", async () => {
+  const { promise, resolve } = Promise.withResolvers<void>();
+  const server = http.createServer((_req, res) => {
+    assert(Object.hasOwn(res, "connection"));
+    assert(res.connection instanceof Socket);
+    res.end();
+  });
+
+  server.listen(async () => {
+    const { port } = server.address() as { port: number };
+    const res = await fetch(`http://localhost:${port}`);
+    await res.body?.cancel();
+    server.close(() => {
+      resolve();
+    });
+  });
+
+  await promise;
+});
+
+Deno.test("[node/http] ServerResponse socket", async () => {
+  const { promise, resolve } = Promise.withResolvers<void>();
+  const server = http.createServer((_req, res) => {
+    assert(Object.hasOwn(res, "socket"));
+    assert(res.socket instanceof Socket);
+    res.end();
+  });
+
+  server.listen(async () => {
+    const { port } = server.address() as { port: number };
+    const res = await fetch(`http://localhost:${port}`);
+    await res.body?.cancel();
+    server.close(() => {
+      resolve();
+    });
+  });
+
+  await promise;
+});
-- 
cgit v1.2.3


From c314b2d8577289078d6b00a0dd58f8f36ff6920a Mon Sep 17 00:00:00 2001
From: familyboat <84062528+familyboat@users.noreply.github.com>
Date: Sun, 27 Oct 2024 11:04:35 +0800
Subject: fix(ext/node): add path to `fs.stat` and `fs.statSync` error (#26037)

---
 tests/unit_node/fs_test.ts | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/fs_test.ts b/tests/unit_node/fs_test.ts
index ef8f829cd..631608d7c 100644
--- a/tests/unit_node/fs_test.ts
+++ b/tests/unit_node/fs_test.ts
@@ -26,6 +26,7 @@ import {
   cp,
   FileHandle,
   open,
+  stat,
   writeFile,
 } from "node:fs/promises";
 import process from "node:process";
@@ -123,6 +124,48 @@ Deno.test(
   },
 );
 
+Deno.test(
+  "[node/fs statSync] throw error with path information",
+  () => {
+    const file = "non-exist-file";
+    const fileUrl = new URL(file, import.meta.url);
+
+    assertThrows(() => {
+      statSync(file);
+    }, "Error: ENOENT: no such file or directory, stat 'non-exist-file'");
+
+    assertThrows(() => {
+      statSync(fileUrl);
+    }, `Error: ENOENT: no such file or directory, stat '${fileUrl.pathname}'`);
+  },
+);
+
+Deno.test(
+  "[node/fs/promises stat] throw error with path information",
+  async () => {
+    const file = "non-exist-file";
+    const fileUrl = new URL(file, import.meta.url);
+
+    try {
+      await stat(file);
+    } catch (error: unknown) {
+      assertEquals(
+        `${error}`,
+        "Error: ENOENT: no such file or directory, stat 'non-exist-file'",
+      );
+    }
+
+    try {
+      await stat(fileUrl);
+    } catch (error: unknown) {
+      assertEquals(
+        `${error}`,
+        `Error: ENOENT: no such file or directory, stat '${fileUrl.pathname}'`,
+      );
+    }
+  },
+);
+
 Deno.test(
   "[node/fs/promises cp] copy file",
   async () => {
-- 
cgit v1.2.3


From a69224ea5bd02f08108aac867c492754095f2d34 Mon Sep 17 00:00:00 2001
From: Yoshiya Hinosawa <stibium121@gmail.com>
Date: Wed, 30 Oct 2024 02:41:16 +0900
Subject: Revert "fix(ext/node): fix dns.lookup result ordering (#26264)"
 (#26621)

This reverts commit d59599fc187c559ee231882773e1c5a2b932fc3d.

Closes #26588
---
 tests/unit_node/http_test.ts |  8 ++------
 tests/unit_node/tls_test.ts  | 12 +++---------
 2 files changed, 5 insertions(+), 15 deletions(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/http_test.ts b/tests/unit_node/http_test.ts
index 84d6f5727..2b3b8f509 100644
--- a/tests/unit_node/http_test.ts
+++ b/tests/unit_node/http_test.ts
@@ -322,14 +322,10 @@ Deno.test("[node/http] IncomingRequest socket has remoteAddress + remotePort", a
     // deno-lint-ignore no-explicit-any
     const port = (server.address() as any).port;
     const res = await fetch(
-      `http://localhost:${port}/`,
+      `http://127.0.0.1:${port}/`,
     );
     await res.arrayBuffer();
-    if (Deno.build.os === "windows") {
-      assertEquals(remoteAddress, "127.0.0.1");
-    } else {
-      assertEquals(remoteAddress, "::1");
-    }
+    assertEquals(remoteAddress, "127.0.0.1");
     assertEquals(typeof remotePort, "number");
     server.close(() => resolve());
   });
diff --git a/tests/unit_node/tls_test.ts b/tests/unit_node/tls_test.ts
index 236dab208..43d6205b0 100644
--- a/tests/unit_node/tls_test.ts
+++ b/tests/unit_node/tls_test.ts
@@ -32,15 +32,13 @@ for (
 ) {
   Deno.test(`tls.connect sends correct ALPN: '${alpnServer}' + '${alpnClient}' = '${expected}'`, async () => {
     const listener = Deno.listenTls({
-      hostname: "localhost",
       port: 0,
       key,
       cert,
       alpnProtocols: alpnServer,
     });
     const outgoing = tls.connect({
-      host: "::1",
-      servername: "localhost",
+      host: "localhost",
       port: listener.addr.port,
       ALPNProtocols: alpnClient,
       secureContext: {
@@ -63,7 +61,6 @@ Deno.test("tls.connect makes tls connection", async () => {
   const ctl = new AbortController();
   let port;
   const serve = Deno.serve({
-    hostname: "localhost",
     port: 0,
     key,
     cert,
@@ -74,8 +71,7 @@ Deno.test("tls.connect makes tls connection", async () => {
   await delay(200);
 
   const conn = tls.connect({
-    host: "::1",
-    servername: "localhost",
+    host: "localhost",
     port,
     secureContext: {
       ca: rootCaCert,
@@ -106,7 +102,6 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
   const { promise, resolve } = Promise.withResolvers<void>();
   const ctl = new AbortController();
   const serve = Deno.serve({
-    hostname: "localhost",
     port: 8443,
     key,
     cert,
@@ -116,8 +111,7 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
   await delay(200);
 
   const conn = tls.connect({
-    host: "::1",
-    servername: "localhost",
+    host: "localhost",
     port: 8443,
     secureContext: {
       ca: rootCaCert,
-- 
cgit v1.2.3


From b3a3d84ce249ff126f92e7a0849ec0a6ce26e973 Mon Sep 17 00:00:00 2001
From: Satya Rohith <me@satyarohith.com>
Date: Wed, 6 Nov 2024 19:42:24 +0530
Subject: fix(node:zlib): gzip & gzipSync should accept ArrayBuffer (#26762)

Closes https://github.com/denoland/deno/issues/26638
---
 tests/unit_node/zlib_test.ts | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/zlib_test.ts b/tests/unit_node/zlib_test.ts
index 8bce5ce7d..0eff95445 100644
--- a/tests/unit_node/zlib_test.ts
+++ b/tests/unit_node/zlib_test.ts
@@ -10,6 +10,7 @@ import {
   createBrotliCompress,
   createBrotliDecompress,
   createDeflate,
+  gzip,
   gzipSync,
   unzipSync,
 } from "node:zlib";
@@ -210,3 +211,17 @@ Deno.test("createBrotliCompress params", async () => {
   );
   assertEquals(output.length, input.length);
 });
+
+Deno.test("gzip() and gzipSync() accept ArrayBuffer", async () => {
+  const deffered = Promise.withResolvers<void>();
+  const buf = new ArrayBuffer(0);
+  let output: Buffer;
+  gzip(buf, (_err, data) => {
+    output = data;
+    deffered.resolve();
+  });
+  await deffered.promise;
+  assert(output! instanceof Buffer);
+  const outputSync = gzipSync(buf);
+  assert(outputSync instanceof Buffer);
+});
-- 
cgit v1.2.3


From c3c2b379669b17e5fdcbe5e62662404ca22c71c6 Mon Sep 17 00:00:00 2001
From: Yoshiya Hinosawa <stibium121@gmail.com>
Date: Tue, 12 Nov 2024 19:54:47 +0900
Subject: fix(ext/node): add autoSelectFamily option to net.createConnection
 (#26661)

---
 tests/unit_node/http2_test.ts | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/http2_test.ts b/tests/unit_node/http2_test.ts
index 7473a487a..c540c90f7 100644
--- a/tests/unit_node/http2_test.ts
+++ b/tests/unit_node/http2_test.ts
@@ -10,6 +10,11 @@ import * as net from "node:net";
 import { assert, assertEquals } from "@std/assert";
 import { curlRequest } from "../unit/test_util.ts";
 
+// Increase the timeout for the auto select family to avoid flakiness
+net.setDefaultAutoSelectFamilyAttemptTimeout(
+  net.getDefaultAutoSelectFamilyAttemptTimeout() * 30,
+);
+
 for (const url of ["http://localhost:4246", "https://localhost:4247"]) {
   Deno.test(`[node/http2 client] ${url}`, {
     ignore: Deno.build.os === "windows",
-- 
cgit v1.2.3


From 43812ee8ff0eb2584c7beb18639da14d96d06817 Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Wed, 13 Nov 2024 08:02:09 +0530
Subject: fix(ext/node): process.getBuiltinModule (#26833)

Closes https://github.com/denoland/deno/issues/26832
---
 tests/unit_node/process_test.ts | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/process_test.ts b/tests/unit_node/process_test.ts
index f9138c8f0..49de2dce1 100644
--- a/tests/unit_node/process_test.ts
+++ b/tests/unit_node/process_test.ts
@@ -1152,3 +1152,9 @@ Deno.test("process.stdout.columns writable", () => {
   process.stdout.columns = 80;
   assertEquals(process.stdout.columns, 80);
 });
+
+Deno.test("getBuiltinModule", () => {
+  assert(process.getBuiltinModule("fs"));
+  assert(process.getBuiltinModule("node:fs"));
+  assertEquals(process.getBuiltinModule("something"), undefined);
+});
-- 
cgit v1.2.3


From 7becd83a3828b35331d0fcb82c64146e520f154b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Czerniawski?=
 <33061335+lczerniawski@users.noreply.github.com>
Date: Wed, 13 Nov 2024 05:35:04 +0100
Subject: feat(ext/fs): add ctime to Deno.stats and use it in node compat layer
 (#24801)

This PR fixes #24453, by introducing a ctime (using ctime for UNIX and
ChangeTime for Windows) to Deno.stats.

Co-authored-by: Yoshiya Hinosawa <stibium121@gmail.com>
---
 tests/unit_node/_fs/_fs_stat_test.ts | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/_fs/_fs_stat_test.ts b/tests/unit_node/_fs/_fs_stat_test.ts
index 02c620e2d..e42aa34a9 100644
--- a/tests/unit_node/_fs/_fs_stat_test.ts
+++ b/tests/unit_node/_fs/_fs_stat_test.ts
@@ -18,9 +18,11 @@ export function assertStats(actual: Stats, expected: Deno.FileInfo) {
   assertEquals(actual.atime?.getTime(), expected.atime?.getTime());
   assertEquals(actual.mtime?.getTime(), expected.mtime?.getTime());
   assertEquals(actual.birthtime?.getTime(), expected.birthtime?.getTime());
+  assertEquals(actual.ctime?.getTime(), expected.ctime?.getTime());
   assertEquals(actual.atimeMs ?? undefined, expected.atime?.getTime());
   assertEquals(actual.mtimeMs ?? undefined, expected.mtime?.getTime());
   assertEquals(actual.birthtimeMs ?? undefined, expected.birthtime?.getTime());
+  assertEquals(actual.ctimeMs ?? undefined, expected.ctime?.getTime());
   assertEquals(actual.isFile(), expected.isFile);
   assertEquals(actual.isDirectory(), expected.isDirectory);
   assertEquals(actual.isSymbolicLink(), expected.isSymlink);
@@ -49,6 +51,7 @@ export function assertStatsBigInt(
   assertEquals(actual.atime?.getTime(), expected.atime?.getTime());
   assertEquals(actual.mtime?.getTime(), expected.mtime?.getTime());
   assertEquals(actual.birthtime?.getTime(), expected.birthtime?.getTime());
+  assertEquals(actual.ctime?.getTime(), expected.ctime?.getTime());
   assertEquals(
     actual.atimeMs === null ? undefined : Number(actual.atimeMs),
     expected.atime?.getTime(),
@@ -61,6 +64,10 @@ export function assertStatsBigInt(
     actual.birthtimeMs === null ? undefined : Number(actual.birthtimeMs),
     expected.birthtime?.getTime(),
   );
+  assertEquals(
+    actual.ctimeMs === null ? undefined : Number(actual.ctimeMs),
+    expected.ctime?.getTime(),
+  );
   assertEquals(actual.atimeNs === null, actual.atime === null);
   assertEquals(actual.mtimeNs === null, actual.mtime === null);
   assertEquals(actual.birthtimeNs === null, actual.birthtime === null);
-- 
cgit v1.2.3


From 7d9ba09f5a4464072476b8992e43f5e5c30bde3a Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Wed, 13 Nov 2024 19:47:01 +0530
Subject: fix(ext/node): use ERR_NOT_IMPLEMENTED for notImplemented (#26853)

---
 tests/unit_node/perf_hooks_test.ts | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/perf_hooks_test.ts b/tests/unit_node/perf_hooks_test.ts
index d5b900041..8247f9fd3 100644
--- a/tests/unit_node/perf_hooks_test.ts
+++ b/tests/unit_node/perf_hooks_test.ts
@@ -1,6 +1,10 @@
 // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
 import * as perfHooks from "node:perf_hooks";
-import { performance, PerformanceObserver } from "node:perf_hooks";
+import {
+  monitorEventLoopDelay,
+  performance,
+  PerformanceObserver,
+} from "node:perf_hooks";
 import { assertEquals, assertThrows } from "@std/assert";
 
 Deno.test({
@@ -68,3 +72,12 @@ Deno.test("[perf_hooks]: eventLoopUtilization", () => {
   assertEquals(typeof obj.active, "number");
   assertEquals(typeof obj.utilization, "number");
 });
+
+Deno.test("[perf_hooks]: monitorEventLoopDelay", () => {
+  const e = assertThrows(() => {
+    monitorEventLoopDelay({ resolution: 1 });
+  });
+
+  // deno-lint-ignore no-explicit-any
+  assertEquals((e as any).code, "ERR_NOT_IMPLEMENTED");
+});
-- 
cgit v1.2.3


From 6a4c6d83bacf5f03628a494778a30bce970f7cbc Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Wed, 13 Nov 2024 20:07:45 +0530
Subject: fix(ext/node): zlib.crc32() (#26856)

Fixes https://github.com/denoland/deno/issues/26845
---
 tests/unit_node/zlib_test.ts | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/zlib_test.ts b/tests/unit_node/zlib_test.ts
index 0eff95445..de2d2450d 100644
--- a/tests/unit_node/zlib_test.ts
+++ b/tests/unit_node/zlib_test.ts
@@ -7,6 +7,7 @@ import {
   brotliCompressSync,
   brotliDecompressSync,
   constants,
+  crc32,
   createBrotliCompress,
   createBrotliDecompress,
   createDeflate,
@@ -225,3 +226,7 @@ Deno.test("gzip() and gzipSync() accept ArrayBuffer", async () => {
   const outputSync = gzipSync(buf);
   assert(outputSync instanceof Buffer);
 });
+
+Deno.test("crc32()", () => {
+  assertEquals(crc32("hello world"), 222957957);
+});
-- 
cgit v1.2.3


From b8cf2599242a9d85d03b57d3649ccdf8bce1530e Mon Sep 17 00:00:00 2001
From: Luca Casonato <hello@lcas.dev>
Date: Fri, 15 Nov 2024 15:54:28 +0100
Subject: feat(fetch): accept async iterables for body (#26882)

Reland of #24623, but with a fix for `String` objects.

Co-authored-by: crowlkats <crowlkats@toaxl.com>
---
 tests/unit_node/fetch_test.ts | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 tests/unit_node/fetch_test.ts

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/fetch_test.ts b/tests/unit_node/fetch_test.ts
new file mode 100644
index 000000000..399d6052a
--- /dev/null
+++ b/tests/unit_node/fetch_test.ts
@@ -0,0 +1,18 @@
+// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
+
+import { assertEquals } from "@std/assert";
+import { createReadStream } from "node:fs";
+
+Deno.test("fetch node stream", async () => {
+  const file = createReadStream("tests/testdata/assets/fixture.json");
+
+  const response = await fetch("http://localhost:4545/echo_server", {
+    method: "POST",
+    body: file,
+  });
+
+  assertEquals(
+    await response.text(),
+    await Deno.readTextFile("tests/testdata/assets/fixture.json"),
+  );
+});
-- 
cgit v1.2.3


From 8d2960d7ccb756de4260a642d960cd01eaaa2478 Mon Sep 17 00:00:00 2001
From: /usr/bin/cat <109351887+cu8code@users.noreply.github.com>
Date: Sat, 16 Nov 2024 20:31:19 +0530
Subject: fix(ext/node): New async setInterval function to improve the nodejs
 compatibility (#26703)

Closes #26499
---
 tests/unit_node/timers_test.ts | 151 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/timers_test.ts b/tests/unit_node/timers_test.ts
index 868ba21d6..c7dc30bbb 100644
--- a/tests/unit_node/timers_test.ts
+++ b/tests/unit_node/timers_test.ts
@@ -3,6 +3,7 @@
 import { assert, fail } from "@std/assert";
 import * as timers from "node:timers";
 import * as timersPromises from "node:timers/promises";
+import { assertEquals } from "@std/assert";
 
 Deno.test("[node/timers setTimeout]", () => {
   {
@@ -108,3 +109,153 @@ Deno.test("[node/timers setImmediate returns Immediate object]", () => {
   imm.hasRef();
   clearImmediate(imm);
 });
+
+Deno.test({
+  name: "setInterval yields correct values at expected intervals",
+  async fn() {
+    // Test configuration
+    const CONFIG = {
+      expectedValue: 42,
+      intervalMs: 100,
+      iterations: 3,
+      tolerancePercent: 10,
+    };
+
+    const { setInterval } = timersPromises;
+    const results: Array<{ value: number; timestamp: number }> = [];
+    const startTime = Date.now();
+
+    const iterator = setInterval(CONFIG.intervalMs, CONFIG.expectedValue);
+
+    for await (const value of iterator) {
+      results.push({
+        value,
+        timestamp: Date.now(),
+      });
+      if (results.length === CONFIG.iterations) {
+        break;
+      }
+    }
+
+    const values = results.map((r) => r.value);
+    assertEquals(
+      values,
+      Array(CONFIG.iterations).fill(CONFIG.expectedValue),
+      `Each iteration should yield ${CONFIG.expectedValue}`,
+    );
+
+    const intervals = results.slice(1).map((result, index) => ({
+      interval: result.timestamp - results[index].timestamp,
+      iterationNumber: index + 1,
+    }));
+
+    const toleranceMs = (CONFIG.tolerancePercent / 100) * CONFIG.intervalMs;
+    const expectedRange = {
+      min: CONFIG.intervalMs - toleranceMs,
+      max: CONFIG.intervalMs + toleranceMs,
+    };
+
+    intervals.forEach(({ interval, iterationNumber }) => {
+      const isWithinTolerance = interval >= expectedRange.min &&
+        interval <= expectedRange.max;
+
+      assertEquals(
+        isWithinTolerance,
+        true,
+        `Iteration ${iterationNumber}: Interval ${interval}ms should be within ` +
+          `${expectedRange.min}ms and ${expectedRange.max}ms ` +
+          `(${CONFIG.tolerancePercent}% tolerance of ${CONFIG.intervalMs}ms)`,
+      );
+    });
+
+    const totalDuration = results[results.length - 1].timestamp - startTime;
+    const expectedDuration = CONFIG.intervalMs * CONFIG.iterations;
+    const isDurationReasonable =
+      totalDuration >= (expectedDuration - toleranceMs) &&
+      totalDuration <= (expectedDuration + toleranceMs);
+
+    assertEquals(
+      isDurationReasonable,
+      true,
+      `Total duration ${totalDuration}ms should be close to ${expectedDuration}ms ` +
+        `(within ${toleranceMs}ms tolerance)`,
+    );
+
+    const timestamps = results.map((r) => r.timestamp);
+    const areTimestampsOrdered = timestamps.every((timestamp, i) =>
+      i === 0 || timestamp > timestamps[i - 1]
+    );
+
+    assertEquals(
+      areTimestampsOrdered,
+      true,
+      "Timestamps should be strictly increasing",
+    );
+  },
+});
+
+Deno.test({
+  name: "setInterval with AbortSignal stops after expected duration",
+  async fn() {
+    const INTERVAL_MS = 500;
+    const TOTAL_DURATION_MS = 3000;
+    const TOLERANCE_MS = 500;
+
+    const abortController = new AbortController();
+    const { setInterval } = timersPromises;
+
+    // Set up abort after specified duration
+    const abortTimeout = timers.setTimeout(() => {
+      abortController.abort();
+    }, TOTAL_DURATION_MS);
+
+    // Track iterations and timing
+    const startTime = Date.now();
+    const iterations: number[] = [];
+
+    try {
+      for await (
+        const _timestamp of setInterval(INTERVAL_MS, undefined, {
+          signal: abortController.signal,
+        })
+      ) {
+        iterations.push(Date.now() - startTime);
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        throw error;
+      }
+    } finally {
+      timers.clearTimeout(abortTimeout);
+    }
+
+    // Validate timing
+    const totalDuration = iterations[iterations.length - 1];
+    const isWithinTolerance =
+      totalDuration >= (TOTAL_DURATION_MS - TOLERANCE_MS) &&
+      totalDuration <= (TOTAL_DURATION_MS + TOLERANCE_MS);
+
+    assertEquals(
+      isWithinTolerance,
+      true,
+      `Total duration ${totalDuration}ms should be within ±${TOLERANCE_MS}ms of ${TOTAL_DURATION_MS}ms`,
+    );
+
+    // Validate interval consistency
+    const intervalDeltas = iterations.slice(1).map((time, i) =>
+      time - iterations[i]
+    );
+
+    intervalDeltas.forEach((delta, i) => {
+      const isIntervalValid = delta >= (INTERVAL_MS - 50) &&
+        delta <= (INTERVAL_MS + 50);
+      assertEquals(
+        isIntervalValid,
+        true,
+        `Interval ${
+          i + 1
+        } duration (${delta}ms) should be within ±50ms of ${INTERVAL_MS}ms`,
+      );
+    });
+  },
+});
-- 
cgit v1.2.3


From f2cd5655c6012202c634cad5b3c136006bf1f0bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= <biwanczuk@gmail.com>
Date: Sat, 16 Nov 2024 16:31:55 +0000
Subject: fix(ext/node): increase tolerance for interval test (#26899)

Fixes tests added in https://github.com/denoland/deno/pull/26703 by
increasing tolerance due to noisy CI machines.
---
 tests/unit_node/timers_test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/timers_test.ts b/tests/unit_node/timers_test.ts
index c7dc30bbb..ddc6dc0d8 100644
--- a/tests/unit_node/timers_test.ts
+++ b/tests/unit_node/timers_test.ts
@@ -118,7 +118,7 @@ Deno.test({
       expectedValue: 42,
       intervalMs: 100,
       iterations: 3,
-      tolerancePercent: 10,
+      tolerancePercent: 50,
     };
 
     const { setInterval } = timersPromises;
-- 
cgit v1.2.3


From df1d36324ffd4f687c406e412f9255bf7a9d8a61 Mon Sep 17 00:00:00 2001
From: Marvin Hagemeister <marvin@deno.com>
Date: Tue, 19 Nov 2024 01:39:40 +0100
Subject: fix(node/crypto): support promisify on generateKeyPair (#26913)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Calling `promisify(generateKeyPair)` didn't work as expected. It
requires a custom promisify implementation.

This was easy to fix thanks to the excellent debugging investigation in
https://github.com/denoland/deno/issues/26910

Fixes https://github.com/denoland/deno/issues/26910

Co-authored-by: Bartek Iwańczuk <biwanczuk@gmail.com>
---
 tests/unit_node/crypto/crypto_key_test.ts | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/crypto/crypto_key_test.ts b/tests/unit_node/crypto/crypto_key_test.ts
index 3c7ad4423..5d206acc7 100644
--- a/tests/unit_node/crypto/crypto_key_test.ts
+++ b/tests/unit_node/crypto/crypto_key_test.ts
@@ -677,3 +677,26 @@ Deno.test("generateKeyPair large pem", function () {
     },
   });
 });
+
+Deno.test("generateKeyPair promisify", async () => {
+  const passphrase = "mypassphrase";
+  const cipher = "aes-256-cbc";
+  const modulusLength = 4096;
+
+  const { privateKey, publicKey } = await promisify(generateKeyPair)("rsa", {
+    modulusLength,
+    publicKeyEncoding: {
+      type: "spki",
+      format: "pem",
+    },
+    privateKeyEncoding: {
+      type: "pkcs8",
+      format: "pem",
+      cipher,
+      passphrase,
+    },
+  });
+
+  assert(publicKey.startsWith("-----BEGIN PUBLIC KEY-----"));
+  assert(privateKey.startsWith("-----BEGIN PRIVATE KEY-----"));
+});
-- 
cgit v1.2.3


From 069bc15030225393f7d05521505316066464bdbd Mon Sep 17 00:00:00 2001
From: Divy Srivastava <dj.srivastava23@gmail.com>
Date: Tue, 19 Nov 2024 16:49:25 +0530
Subject: feat(ext/node): perf_hooks.monitorEventLoopDelay() (#26905)

Fixes https://github.com/denoland/deno/issues/20961

Depends on https://github.com/denoland/deno_core/pull/965 and
https://github.com/denoland/deno_core/pull/966
---
 tests/unit_node/perf_hooks_test.ts | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

(limited to 'tests/unit_node')

diff --git a/tests/unit_node/perf_hooks_test.ts b/tests/unit_node/perf_hooks_test.ts
index 8247f9fd3..83d006222 100644
--- a/tests/unit_node/perf_hooks_test.ts
+++ b/tests/unit_node/perf_hooks_test.ts
@@ -5,7 +5,7 @@ import {
   performance,
   PerformanceObserver,
 } from "node:perf_hooks";
-import { assertEquals, assertThrows } from "@std/assert";
+import { assert, assertEquals, assertThrows } from "@std/assert";
 
 Deno.test({
   name: "[perf_hooks] performance",
@@ -73,11 +73,16 @@ Deno.test("[perf_hooks]: eventLoopUtilization", () => {
   assertEquals(typeof obj.utilization, "number");
 });
 
-Deno.test("[perf_hooks]: monitorEventLoopDelay", () => {
-  const e = assertThrows(() => {
-    monitorEventLoopDelay({ resolution: 1 });
-  });
+Deno.test("[perf_hooks]: monitorEventLoopDelay", async () => {
+  const e = monitorEventLoopDelay();
+  assertEquals(e.count, 0);
+  e.enable();
 
-  // deno-lint-ignore no-explicit-any
-  assertEquals((e as any).code, "ERR_NOT_IMPLEMENTED");
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  assert(e.min > 0);
+  assert(e.minBigInt > 0n);
+  assert(e.count > 0);
+
+  e.disable();
 });
-- 
cgit v1.2.3