Open History to see the last commit
1// Exercise the raw Node HTTP boundary before Effect attaches serving handlers.
2// @effect-diagnostics nodeBuiltinImport:off
3import * as NodeHttp from "node:http";
4import * as NodeNet from "node:net";
5import { afterEach, describe, expect, it } from "vite-plus/test";
6
7import * as HttpResponseErrorGuard from "./httpResponseErrorGuard.ts";
8
9const { guardHttpResponseWriteErrors } = HttpResponseErrorGuard;
10
11const servers: NodeHttp.Server[] = [];
12const requests: NodeHttp.ClientRequest[] = [];
13const sockets: NodeNet.Socket[] = [];
14
15function listen(server: NodeHttp.Server): Promise<number> {
16 servers.push(server);
17 server.on("connection", (socket) => sockets.push(socket));
18 return new Promise((resolve, reject) => {
19 server.once("error", reject);
20 server.listen(0, "127.0.0.1", () => {
21 resolve((server.address() as NodeNet.AddressInfo).port);
22 });
23 });
24}
25
26function fetchResponse(
27 port: number,
28 path: string,
29 upgrade = false,
30): Promise<NodeHttp.IncomingMessage> {
31 return new Promise((resolve, reject) => {
32 const request = NodeHttp.get(
33 {
34 host: "127.0.0.1",
35 port,
36 path,
37 agent: false,
38 headers: upgrade
39 ? {
40 connection: "Upgrade",
41 upgrade: "websocket",
42 "sec-websocket-key": "dGhlIHNhbXBsZSBub25jZQ==",
43 "sec-websocket-version": "13",
44 }
45 : {},
46 },
47 (response) => {
48 response.on("error", reject);
49 response.on("end", () => resolve(response));
50 response.resume();
51 },
52 );
53 requests.push(request);
54 request.on("error", reject);
55 request.on("upgrade", (response, socket) => {
56 socket.destroy();
57 resolve(response);
58 });
59 });
60}
61
62function fetchStatus(port: number, path: string): Promise<number> {
63 return fetchResponse(port, path).then((response) => response.statusCode ?? 0);
64}
65
66afterEach(async () => {
67 for (const request of requests.splice(0)) {
68 request.destroy();
69 }
70 for (const socket of sockets.splice(0)) {
71 socket.destroy();
72 }
73 await Promise.all(
74 servers
75 .splice(0)
76 .map((server) => new Promise<void>((resolve) => server.close(() => resolve()))),
77 );
78});
79
80describe("guardHttpResponseWriteErrors", () => {
81 it("contains an upgrade socket write failure instead of crashing the process", async () => {
82 const writeErrors: unknown[] = [];
83 const failureObserved = Promise.withResolvers<void>();
84 const server = guardHttpResponseWriteErrors(NodeHttp.createServer(), (error) => {
85 writeErrors.push(error);
86 failureObserved.resolve();
87 });
88
89 server.on("upgrade", (_request, socket) => {
90 // Node's HTTP server no longer listens for errors on an upgraded socket.
91 socket.destroy(Object.assign(new Error("write EPIPE"), { code: "EPIPE" }));
92 });
93
94 const port = await listen(server);
95
96 const client = NodeNet.connect(port, "127.0.0.1", () => {
97 client.write(
98 [
99 "GET /rpc HTTP/1.1",
100 "Host: 127.0.0.1",
101 "Connection: Upgrade",
102 "Upgrade: websocket",
103 "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==",
104 "Sec-WebSocket-Version: 13",
105 "",
106 "",
107 ].join("\r\n"),
108 );
109 });
110 sockets.push(client);
111 client.on("error", () => {});
112
113 await failureObserved.promise;
114 client.destroy();
115
116 expect(writeErrors).toHaveLength(1);
117 expect(writeErrors[0]).toBeInstanceOf(Error);
118 expect((writeErrors[0] as NodeJS.ErrnoException).code).toBe("EPIPE");
119
120 server.on("request", (_request, response) => {
121 response.writeHead(200, { "content-type": "text/plain" });
122 response.end("ok");
123 });
124 await expect(fetchStatus(port, "/")).resolves.toBe(200);
125 });
126});
127
128describe("rejectRequestsUntilServing", () => {
129 it("rejects early HTTP and upgrades, then hands each off to its serving handler", async () => {
130 const writeErrors: unknown[] = [];
131 const server = HttpResponseErrorGuard.rejectRequestsUntilServing(
132 guardHttpResponseWriteErrors(NodeHttp.createServer(), (error) => writeErrors.push(error)),
133 );
134 const port = await listen(server);
135
136 const earlyHttp = await fetchResponse(port, "/");
137 expect(earlyHttp.statusCode).toBe(503);
138 expect(earlyHttp.headers["retry-after"]).toBe("1");
139
140 const earlyUpgrade = await fetchResponse(port, "/rpc", true);
141 expect(earlyUpgrade.statusCode).toBe(503);
142 expect(earlyUpgrade.headers["retry-after"]).toBe("1");
143
144 server.on("request", (_request, response) => response.writeHead(204).end());
145
146 const servingHttp = await fetchResponse(port, "/");
147 expect(servingHttp.statusCode).toBe(204);
148 expect(servingHttp.headers["retry-after"]).toBeUndefined();
149
150 const pendingUpgrade = await fetchResponse(port, "/rpc", true);
151 expect(pendingUpgrade.statusCode).toBe(503);
152 expect(pendingUpgrade.headers["retry-after"]).toBe("1");
153
154 server.on("upgrade", (_request, socket) => {
155 socket.end(
156 "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n",
157 );
158 });
159
160 const servingUpgrade = await fetchResponse(port, "/rpc", true);
161 expect(servingUpgrade.statusCode).toBe(101);
162 expect(servingUpgrade.headers["retry-after"]).toBeUndefined();
163 expect(writeErrors).toEqual([]);
164 });
165});