test(vite): open a real wss handshake on the https hub server

Author: erkamyaman

packages/vite/test/hub.test.ts

@@ -1,26 +1,42 @@
-import type { IncomingMessage, Server as NodeHttpServer, ServerResponse } from 'node:http'
+import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { Http2SecureServer } from 'node:http2'
+import type { Socket } from 'node:net'
 import type { ViteDevServer } from 'vite'
-import { mkdtempSync } from 'node:fs'
-import { createServer } from 'node:http'
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, readFileSync } from 'node:fs'
 import { createSecureServer } from 'node:http2'
+import { request } from 'node:https'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { getPort } from 'get-port-please'
-import { afterEach, describe, expect, it } from 'vitest'
+import { afterEach, beforeAll, describe, expect, it } from 'vitest'
+import { WebSocket } from 'ws'
 import { viteDevframeHub } from '../src/hub'
 
 type ConnectMiddleware = (req: IncomingMessage, res: ServerResponse, next: () => void) => void
 
+function hasOpenssl(): boolean {
+  try {
+    execFileSync('openssl', ['version'], { stdio: 'ignore' })
+    return true
+  }
+  catch {
+    return false
+  }
+}
+
+const opensslAvailable = hasOpenssl()
+if (!opensslAvailable)
+  console.warn('[vite hub test] openssl not found, skipping the https dev server test')
+
 /**
- * Vite on `server.https` hands plugins an `Http2SecureServer` (with
- * `allowHTTP1`), which is not a `node:http` `Server`. Requests are served
- * here over a plain HTTP server running the same middleware stack, so the
- * test needs no certificate.
+ * Vite on `server.https` hands plugins an `Http2SecureServer` with
+ * `allowHTTP1`, which is not a `node:http` `Server`. This one runs the
+ * plugin's connect middlewares like Vite does.
  */
-function fakeHttpsViteServer() {
+function fakeHttpsViteServer(tls: { key: string, cert: string }) {
   const stack: ConnectMiddleware[] = []
-  const requestServer: NodeHttpServer = createServer((req, res) => {
+  const httpServer: Http2SecureServer = createSecureServer({ ...tls, allowHTTP1: true })
+  httpServer.on('request', (req: IncomingMessage, res: ServerResponse) => {
     let i = 0
     const next = (): void => {
       const handler = stack[i++]
@@ -33,46 +49,99 @@ function fakeHttpsViteServer() {
     }
     next()
   })
-  const httpServer: Http2SecureServer = createSecureServer({ allowHTTP1: true })
+  const sockets = new Set<Socket>()
+  httpServer.on('secureConnection', (socket: Socket) => {
+    sockets.add(socket)
+    socket.once('close', () => sockets.delete(socket))
+  })
   const server = {
     httpServer,
     resolvedUrls: null,
     middlewares: { use: (handler: ConnectMiddleware) => stack.push(handler) },
   }
-  return { server, httpServer, requestServer }
+  const close = async (): Promise<void> => {
+    for (const socket of sockets)
+      socket.destroy()
+    await new Promise<void>(resolve => httpServer.close(() => resolve()))
+  }
+  return { server, httpServer, close }
+}
+
+function getInsecure(url: string): Promise<{ status: number, body: string }> {
+  return new Promise((resolve, reject) => {
+    request(url, { rejectUnauthorized: false }, (res) => {
+      let body = ''
+      res.setEncoding('utf8')
+      res.on('data', (chunk: string) => body += chunk)
+      res.on('end', () => resolve({ status: res.statusCode ?? 0, body }))
+    }).on('error', reject).end()
+  })
+}
+
+function openWs(url: string): Promise<WebSocket> {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url, { rejectUnauthorized: false })
+    ws.once('open', () => resolve(ws))
+    ws.once('error', reject)
+  })
 }
 
-describe('viteDevframeHub', () => {
+describe.skipIf(!opensslAvailable)('viteDevframeHub', () => {
+  let tls: { key: string, cert: string }
   let cleanup: (() => Promise<void>) | undefined
 
+  beforeAll(() => {
+    const dir = mkdtempSync(join(tmpdir(), 'devframe-vite-hub-tls-'))
+    const keyPath = join(dir, 'key.pem')
+    const certPath = join(dir, 'cert.pem')
+    execFileSync('openssl', [
+      'req',
+      '-x509',
+      '-newkey',
+      'rsa:2048',
+      '-nodes',
+      '-keyout',
+      keyPath,
+      '-out',
+      certPath,
+      '-days',
+      '1',
+      '-subj',
+      '/CN=localhost',
+    ], { stdio: 'ignore' })
+    tls = { key: readFileSync(keyPath, 'utf8'), cert: readFileSync(certPath, 'utf8') }
+  })
+
   afterEach(async () => {
     await cleanup?.()
     cleanup = undefined
   })
 
   it('shares an https (http2) dev server for the WebSocket upgrade', async () => {
     const host = '127.0.0.1'
-    const port = await getPort({ port: 19800, host })
-    const { server, httpServer, requestServer } = fakeHttpsViteServer()
-    await new Promise<void>(resolve => requestServer.listen(port, host, resolve))
+    const { server, httpServer, close } = fakeHttpsViteServer(tls)
+    await new Promise<void>(resolve => httpServer.listen(0, host, resolve))
+    const { port } = httpServer.address() as { port: number }
 
     const plugin = viteDevframeHub({
       ui: false,
       auth: false,
       quiet: true,
       cwd: mkdtempSync(join(tmpdir(), 'devframe-vite-hub-')),
     })
+    let ws: WebSocket | undefined
     cleanup = async () => {
-      httpServer.emit('close')
+      ws?.terminate()
       await (plugin.closeBundle as () => Promise<void>)()
-      requestServer.close()
-      requestServer.closeAllConnections()
+      await close()
     }
     await (plugin.configureServer as (s: ViteDevServer) => Promise<void>)(server as any)
 
-    const res = await fetch(`http://${host}:${port}/__devframes/__connection.json`)
-    const meta = await res.json() as { websocket?: unknown }
-    expect(meta.websocket).toEqual({ path: '/__devframes/__ws' })
-    expect(httpServer.listenerCount('upgrade')).toBe(1)
+    const res = await getInsecure(`https://${host}:${port}/__devframes/__connection.json`)
+    expect(res.status).toBe(200)
+    expect((JSON.parse(res.body) as { websocket?: unknown }).websocket).toEqual({ path: '/__devframes/__ws' })
+
+    ws = await openWs(`wss://${host}:${port}/__devframes/__ws`)
+    expect(ws.readyState).toBe(WebSocket.OPEN)
   })
 })