1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-25 08:39:09 -05:00
denoland-deno/tests/unit_node/http2_test.ts

394 lines
10 KiB
TypeScript
Raw Normal View History

// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
// deno-lint-ignore-file no-console
import * as http2 from "node:http2";
import { Buffer } from "node:buffer";
import { readFile } from "node:fs/promises";
import { join } from "node:path";
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",
}, async () => {
// Create a server to respond to the HTTP2 requests
const client = http2.connect(url, {});
client.on("error", (err) => console.error(err));
const req = client.request({ ":method": "POST", ":path": "/" }, {
waitForTrailers: true,
});
let receivedTrailers;
let receivedHeaders;
let receivedData = "";
req.on("response", (headers, _flags) => {
receivedHeaders = headers;
});
req.write("hello");
req.setEncoding("utf8");
req.on("wantTrailers", () => {
req.sendTrailers({ foo: "bar" });
});
req.on("trailers", (trailers, _flags) => {
receivedTrailers = trailers;
});
req.on("data", (chunk) => {
receivedData += chunk;
});
req.end();
const { promise, resolve } = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
} catch (_) {
// pass
}
resolve();
}, 2000);
await promise;
assertEquals(receivedHeaders, { ":status": 200 });
assertEquals(receivedData, "hello world\n");
assertEquals(receivedTrailers, {
"abc": "def",
"opr": "stv",
"foo": "bar",
});
});
}
Deno.test(`[node/http2 client createConnection]`, {
ignore: Deno.build.os === "windows",
}, async () => {
const url = "http://127.0.0.1:4246";
const createConnDeferred = Promise.withResolvers<void>();
// Create a server to respond to the HTTP2 requests
const client = http2.connect(url, {
createConnection() {
const socket = net.connect({ host: "127.0.0.1", port: 4246 });
socket.on("connect", () => {
createConnDeferred.resolve();
});
return socket;
},
});
client.on("error", (err) => console.error(err));
const req = client.request({ ":method": "POST", ":path": "/" });
let receivedData = "";
req.write("hello");
req.setEncoding("utf8");
req.on("data", (chunk) => {
receivedData += chunk;
});
req.end();
const endPromise = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
} catch (_) {
// pass
}
endPromise.resolve();
}, 2000);
await createConnDeferred.promise;
await endPromise.promise;
assertEquals(receivedData, "hello world\n");
});
Deno.test("[node/http2 client GET https://www.example.com]", async () => {
const clientSession = http2.connect("https://www.example.com");
const req = clientSession.request({
":method": "GET",
":path": "/",
});
let headers = {};
let status: number | undefined = 0;
let chunk = new Uint8Array();
const endPromise = Promise.withResolvers<void>();
req.on("response", (h) => {
status = h[":status"];
headers = h;
});
req.on("data", (c) => {
chunk = c;
});
req.on("end", () => {
clientSession.close();
req.close();
endPromise.resolve();
});
req.end();
await endPromise.promise;
assert(Object.keys(headers).length > 0);
assertEquals(status, 200);
assert(chunk.length > 0);
});
Deno.test("[node/http2.createServer()]", {
// TODO(satyarohith): enable the test on windows.
ignore: Deno.build.os === "windows",
}, async () => {
const serverListening = Promise.withResolvers<number>();
const server = http2.createServer((_req, res) => {
res.setHeader("Content-Type", "text/html");
res.setHeader("X-Foo", "bar");
res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
res.write("Hello, World!");
res.end();
});
server.listen(0, () => {
serverListening.resolve((server.address() as net.AddressInfo).port);
});
const port = await serverListening.promise;
const endpoint = `http://localhost:${port}`;
const response = await curlRequest([
endpoint,
"--http2-prior-knowledge",
]);
assertEquals(response, "Hello, World!");
server.close();
// Wait to avoid leaking the timer from here
// https://github.com/denoland/deno/blob/749b6e45e58ac87188027f79fe403d130f86bd73/ext/node/polyfills/net.ts#L2396-L2402
// Issue: https://github.com/denoland/deno/issues/22764
await new Promise<void>((resolve) => server.on("close", resolve));
});
Deno.test("[node/http2 client] write image buffer on request stream works", async () => {
const url = "https://localhost:5545";
const client = http2.connect(url);
client.on("error", (err) => console.error(err));
const imagePath = join(import.meta.dirname!, "testdata", "green.jpg");
const buffer = await readFile(imagePath);
const req = client.request({ ":method": "POST", ":path": "/echo_server" });
req.write(buffer, (err) => {
if (err) throw err;
});
let receivedData: Buffer;
req.on("data", (chunk) => {
if (!receivedData) {
receivedData = chunk;
} else {
receivedData = Buffer.concat([receivedData, chunk]);
}
});
req.end();
const endPromise = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
} catch (_) {
// pass
}
endPromise.resolve();
}, 2000);
await endPromise.promise;
assertEquals(receivedData!, buffer);
});
Deno.test("[node/http2 client] write 512kb buffer on request stream works", async () => {
const url = "https://localhost:5545";
const client = http2.connect(url);
client.on("error", (err) => console.error(err));
const filePath = join(
import.meta.dirname!,
"testdata",
"lorem_ipsum_512kb.txt",
);
const buffer = await readFile(filePath);
const req = client.request({ ":method": "POST", ":path": "/echo_server" });
req.write(buffer, (err) => {
if (err) throw err;
});
let receivedData: Buffer;
req.on("data", (chunk) => {
if (!receivedData) {
receivedData = chunk;
} else {
receivedData = Buffer.concat([receivedData, chunk]);
}
});
req.end();
const endPromise = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
} catch (_) {
// pass
}
endPromise.resolve();
}, 2000);
await endPromise.promise;
assertEquals(receivedData!, buffer);
});
// https://github.com/denoland/deno/issues/24678
Deno.test("[node/http2 client] deno doesn't panic on uppercase headers", async () => {
const url = "http://127.0.0.1:4246";
const client = http2.connect(url);
client.on("error", (err) => console.error(err));
// The "User-Agent" header has uppercase characters to test the panic.
const req = client.request({
":method": "POST",
":path": "/",
"User-Agent": "http2",
});
const endPromise = Promise.withResolvers<void>();
let receivedData = "";
req.write("hello");
req.setEncoding("utf8");
req.on("data", (chunk) => {
receivedData += chunk;
});
req.on("end", () => {
req.close();
client.close();
endPromise.resolve();
});
req.end();
await endPromise.promise;
assertEquals(receivedData, "hello world\n");
});
Deno.test("[node/http2 ClientHttp2Session.socket]", async () => {
const url = "http://127.0.0.1:4246";
const client = http2.connect(url);
client.on("error", (err) => console.error(err));
const req = client.request({ ":method": "POST", ":path": "/" });
const endPromise = Promise.withResolvers<void>();
// test that we can access session.socket
client.socket.setTimeout(10000);
// nodejs allows setting arbitrary properties
// deno-lint-ignore no-explicit-any
(client.socket as any).nonExistant = 9001;
// deno-lint-ignore no-explicit-any
assertEquals((client.socket as any).nonExistant, 9001);
// regular request dance to make sure it keeps working
let receivedData = "";
req.write("hello");
req.setEncoding("utf8");
req.on("data", (chunk) => {
receivedData += chunk;
});
req.on("end", () => {
req.close();
client.close();
endPromise.resolve();
});
req.end();
await endPromise.promise;
assertEquals(client.socket.remoteAddress, "127.0.0.1");
assertEquals(client.socket.remotePort, 4246);
assertEquals(client.socket.remoteFamily, "IPv4");
client.socket.setTimeout(0);
assertEquals(receivedData, "hello world\n");
});
Deno.test("[node/http2 client] connection states", async () => {
const expected = {
beforeConnect: { connecting: true, closed: false, destroyed: false },
afterConnect: { connecting: false, closed: false, destroyed: false },
afterClose: { connecting: false, closed: true, destroyed: false },
afterDestroy: { connecting: false, closed: true, destroyed: true },
};
const actual: Partial<typeof expected> = {};
const url = "http://127.0.0.1:4246";
const connectPromise = Promise.withResolvers<void>();
const client = http2.connect(url, {}, () => {
connectPromise.resolve();
});
client.on("error", (err) => console.error(err));
// close event happens after destory has been called
const destroyPromise = Promise.withResolvers<void>();
client.on("close", () => {
destroyPromise.resolve();
});
actual.beforeConnect = {
connecting: client.connecting,
closed: client.closed,
destroyed: client.destroyed,
};
await connectPromise.promise;
actual.afterConnect = {
connecting: client.connecting,
closed: client.closed,
destroyed: client.destroyed,
};
// leave a request open to prevent immediate destroy
const req = client.request();
req.on("data", () => {});
req.on("error", (err) => console.error(err));
const reqClosePromise = Promise.withResolvers<void>();
req.on("close", () => {
reqClosePromise.resolve();
});
client.close();
actual.afterClose = {
connecting: client.connecting,
closed: client.closed,
destroyed: client.destroyed,
};
await destroyPromise.promise;
actual.afterDestroy = {
connecting: client.connecting,
closed: client.closed,
destroyed: client.destroyed,
};
await reqClosePromise.promise;
assertEquals(actual, expected);
});
Deno.test("request and response exports", () => {
assert(http2.Http2ServerRequest);
assert(http2.Http2ServerResponse);
});