test: fix undici 8 websocket and proxy tests

Author: mcollina

test/client-proxy/test-http-proxy-request-invalid-url.mjs

@@ -1,30 +1,33 @@
-// This tests that invalid proxy URLs are handled correctly.
+// This tests that a scheme-less proxy value no longer crashes startup.
 import * as common from '../common/index.mjs';
 import assert from 'node:assert';
 import { once } from 'events';
 import http from 'node:http';
 import { runProxiedRequest } from '../common/proxy-server.js';
 
-// Start a target server that should not be reached.
-const server = http.createServer(common.mustNotCall());
+// Start a target server. The built-in http agent still ignores a scheme-less
+// proxy value, so the request is sent directly.
+const server = http.createServer(common.mustCall((req, res) => {
+  assert.strictEqual(req.url, '/test');
+  res.end('Hello world');
+}));
 server.on('error', common.mustNotCall((err) => { console.error('Server error', err); }));
 server.listen(0);
 await once(server, 'listening');
 
 const serverHost = `localhost:${server.address().port}`;
 const requestUrl = `http://${serverHost}/test`;
 
-// Test invalid proxy URL
 const { code, signal, stderr, stdout } = await runProxiedRequest({
   NODE_USE_ENV_PROXY: 1,
   REQUEST_URL: requestUrl,
   HTTP_PROXY: 'not-a-valid-url',
 });
 
-// Should get an error about invalid URL
-assert.match(stderr, /TypeError.*Invalid URL/);
-assert.strictEqual(stdout.trim(), '');
-assert.strictEqual(code, 1);
+assert.strictEqual(stderr.trim(), '');
+assert.match(stdout, /Status Code: 200/);
+assert.match(stdout, /Hello world/);
+assert.strictEqual(code, 0);
 assert.strictEqual(signal, null);
 
 server.close();

test/client-proxy/test-https-proxy-request-invalid-url.mjs

@@ -1,4 +1,5 @@
-// This tests that invalid proxy URLs are handled correctly for HTTPS requests.
+// This tests that a scheme-less proxy value no longer crashes startup for
+// HTTPS requests.
 import * as common from '../common/index.mjs';
 import fixtures from '../common/fixtures.js';
 import assert from 'node:assert';
@@ -15,26 +16,28 @@ const { default: https } = await import('node:https');
 const server = https.createServer({
   cert: fixtures.readKey('agent8-cert.pem'),
   key: fixtures.readKey('agent8-key.pem'),
-}, common.mustNotCall());
+}, common.mustCall((req, res) => {
+  assert.strictEqual(req.url, '/test');
+  res.end('Hello world');
+}));
 server.on('error', common.mustNotCall((err) => { console.error('Server error', err); }));
 server.listen(0);
 await once(server, 'listening');
 
 const serverHost = `localhost:${server.address().port}`;
 const requestUrl = `https://${serverHost}/test`;
 
-// Test invalid proxy URL
 const { code, signal, stderr, stdout } = await runProxiedRequest({
   NODE_USE_ENV_PROXY: 1,
   REQUEST_URL: requestUrl,
   HTTPS_PROXY: 'not-a-valid-url',
   NODE_EXTRA_CA_CERTS: fixtures.path('keys', 'fake-startcom-root-cert.pem'),
 });
 
-// Should get an error about invalid URL
-assert.match(stderr, /TypeError.*Invalid URL/);
-assert.strictEqual(stdout.trim(), '');
-assert.strictEqual(code, 1);
+assert.strictEqual(stderr.trim(), '');
+assert.match(stdout, /Status Code: 200/);
+assert.match(stdout, /Hello world/);
+assert.strictEqual(code, 0);
 assert.strictEqual(signal, null);
 
 server.close();

test/common/websocket-server.js

@@ -17,6 +17,8 @@ class WebSocketServer {
     this.customHandleUpgradeHeaders = customHandleUpgradeHeaders;
 
     this.server.on('upgrade', this.handleUpgrade.bind(this));
+    this.server.on('connect', this.handleConnect.bind(this));
+    this.server.on('stream', this.handleStream.bind(this));
   }
 
   start() {
@@ -42,32 +44,86 @@ class WebSocketServer {
     ];
 
     socket.write(responseHeaders.join('\r\n') + '\r\n\r\n');
-    this.clients.add(socket);
+    this.addClient(socket, {
+      close: () => socket.end(),
+    });
+  }
+
+  handleConnect(req, response) {
+    if (req.headers[':protocol'] !== 'websocket') {
+      return;
+    }
+
+    const stream = response.stream;
+    const key = req.headers['sec-websocket-key'];
+    const acceptKey = this.generateAcceptValue(key);
+    stream.respond({
+      ':status': 200,
+      'sec-websocket-accept': acceptKey,
+      ...this.getCustomHeadersObject(),
+    });
+
+    this.addClient(stream, {
+      close: () => stream.end(),
+    });
+  }
 
-    socket.on('data', (buffer) => {
+  handleStream(stream, headers) {
+    if (stream.headersSent ||
+        headers[':method'] !== 'CONNECT' ||
+        headers[':protocol'] !== 'websocket') {
+      return;
+    }
+
+    const key = headers['sec-websocket-key'];
+    const acceptKey = this.generateAcceptValue(key);
+    stream.respond({
+      ':status': 200,
+      'sec-websocket-accept': acceptKey,
+      ...this.getCustomHeadersObject(),
+    });
+
+    this.addClient(stream, {
+      close: () => stream.end(),
+    });
+  }
+
+  addClient(client, { close }) {
+    this.clients.add(client);
+
+    client.on('data', (buffer) => {
       const opcode = buffer[0] & 0x0f;
 
       if (opcode === 0x8) {
         // Send a minimal close frame in response:
-        socket.write(Buffer.from([0x88, 0x00]));
-        socket.end();
-        this.clients.delete(socket);
+        client.write(Buffer.from([0x88, 0x00]));
+        close();
+        this.clients.delete(client);
         return;
       }
 
-      socket.write(this.encodeMessage('Hello from server!'));
+      client.write(this.encodeMessage('Hello from server!'));
     });
 
-    socket.on('close', () => {
-      this.clients.delete(socket);
+    client.on('close', () => {
+      this.clients.delete(client);
     });
 
-    socket.on('error', (err) => {
+    client.on('error', (err) => {
       console.error('Socket error:', err);
-      this.clients.delete(socket);
+      this.clients.delete(client);
     });
   }
 
+  getCustomHeadersObject() {
+    return Object.fromEntries(
+      this.customHandleUpgradeHeaders.map((header) => {
+        const index = header.indexOf(':');
+        return [header.slice(0, index).trim(), header.slice(index + 1).trim()];
+      })
+    );
+  }
+
   generateAcceptValue(secWebSocketKey) {
     return crypto
       .createHash('sha1')

test/parallel/test-http2-allow-http1-upgrade-ws.js

@@ -15,10 +15,13 @@ const WebSocketServer = require('../common/websocket-server');
     key: fixtures.readKey('agent1-key.pem'),
     cert: fixtures.readKey('agent1-cert.pem'),
     allowHTTP1: true,
+    settings: {
+      enableConnectProtocol: true,
+    },
   });
 
   server.on('request', common.mustNotCall());
-  new WebSocketServer({ server }); // Handles websocket 'upgrade' events
+  new WebSocketServer({ server });
 
   await new Promise((resolve) => server.listen(0, resolve));