fix: patch node:net early; add http tests

Author: kettanaito

src/interceptors/net/index.ts

@@ -16,6 +16,46 @@ export interface SocketConnectionEventMap {
   ]
 }
 
+const kImplementation = Symbol('kImplementation')
+const kRestoreValue = Symbol('kRestoreValue')
+
+/**
+ * Apply a transparent proxy to the "node:net" module on the module's scope.
+ * This way, this interceptor can function if it gets imported before the surface
+ * that relies on "node:net", like "node:http" or "undici".
+ *
+ * @note You MUST import the interceptor BEFORE the surface relying on "node:net".
+ */
+const { createConnection } = net
+Object.defineProperties(net.createConnection, {
+  [kRestoreValue]: {
+    value: createConnection.bind(createConnection),
+    enumerable: true,
+  },
+  [kImplementation]: {
+    value() {
+      return Reflect.get(net.createConnection, kRestoreValue)
+    },
+    enumerable: true,
+    writable: true,
+  },
+})
+
+function createSwitchableProxy(target: any) {
+  return new Proxy(target, {
+    apply(target, thisArg, argArray) {
+      return Reflect.apply(
+        Reflect.get(target, kImplementation),
+        thisArg,
+        argArray
+      )
+    },
+  })
+}
+
+net.connect = createSwitchableProxy(net.connect)
+net.createConnection = createSwitchableProxy(net.createConnection)
+
 export class SocketInterceptor extends Interceptor<SocketConnectionEventMap> {
   static symbol = Symbol('SocketInterceptor')
 
@@ -24,20 +64,21 @@ export class SocketInterceptor extends Interceptor<SocketConnectionEventMap> {
   }
 
   protected setup(): void {
-    const {
-      connect: originalConnect,
-      createConnection: originalCreateConnection,
-    } = net
+    const originalConnect = Reflect.get(net.connect, kRestoreValue)
+    const originalCreateConnection = Reflect.get(
+      net.createConnection,
+      kRestoreValue
+    )
 
-    net.connect = (...args: Array<unknown>) => {
+    Reflect.set(net.connect, kImplementation, (...args: Array<unknown>) => {
       const [options, connectionListener] = normalizeNetConnectArgs(
         args as NetConnectArgs
       )
       const socket = new MockSocket({
         ...args,
         onConnect: connectionListener,
         createConnection() {
-          return originalConnect.apply(originalCreateConnection, args as any)
+          return originalConnect.apply(originalConnect, args as any)
         },
       })
 
@@ -47,31 +88,39 @@ export class SocketInterceptor extends Interceptor<SocketConnectionEventMap> {
       })
 
       return socket
-    }
+    })
 
-    net.createConnection = (...args: Array<unknown>) => {
-      const [options] = normalizeNetConnectArgs(args as NetConnectArgs)
-      const socket = new MockSocket({
-        ...args,
-        createConnection() {
-          return originalCreateConnection.apply(
-            originalCreateConnection,
-            args as any
-          )
-        },
-      })
+    Reflect.set(
+      net.createConnection,
+      kImplementation,
+      (...args: Array<unknown>) => {
+        const [options] = normalizeNetConnectArgs(args as NetConnectArgs)
+        const socket = new MockSocket({
+          ...args,
+          createConnection() {
+            return originalCreateConnection.apply(
+              originalCreateConnection,
+              args as any
+            )
+          },
+        })
 
-      this.emitter.emit('connection', {
-        options,
-        socket,
-      })
+        this.emitter.emit('connection', {
+          options,
+          socket,
+        })
 
-      return socket
-    }
+        return socket
+      }
+    )
 
     this.subscriptions.push(() => {
-      net.connect = originalConnect
-      net.createConnection = originalCreateConnection
+      Reflect.set(net.connect, kImplementation, originalConnect)
+      Reflect.set(
+        net.createConnection,
+        kImplementation,
+        originalCreateConnection
+      )
     })
   }
 }

test/modules/net/net.http.test.ts

@@ -0,0 +1,91 @@
+// @vitest-environment node
+import { SocketInterceptor } from '../../../src/interceptors/net'
+import http from 'node:http'
+import { beforeAll, afterEach, afterAll, vi, it, expect } from 'vitest'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { waitForClientRequest } from '../../helpers'
+
+export const interceptor = new SocketInterceptor()
+
+beforeAll(() => {
+  interceptor.apply()
+})
+
+afterEach(() => {
+  interceptor.removeAllListeners()
+})
+
+afterAll(() => {
+  interceptor.dispose()
+})
+
+it('intercepts an http request without any body', async () => {
+  const requestHeader = new DeferredPromise<string>()
+  const errorListener = vi.fn()
+
+  interceptor.on('connection', ({ socket }) => {
+    socket.on('error', errorListener)
+    socket.once('write', (chunk) => requestHeader.resolve(chunk))
+    socket.push('HTTP/1.1 200 OK\r\n\r\n')
+    socket.push('hello world')
+    socket.push(null)
+  })
+
+  const request = http.get('http://localhost/resource')
+  const { res, text } = await waitForClientRequest(request)
+
+  await expect.soft(requestHeader).resolves.toBe(`GET /resource HTTP/1.1\r
+Host: localhost\r
+Connection: close\r
+\r
+`)
+
+  expect.soft(res.statusCode).toBe(200)
+  await expect.soft(text()).resolves.toBe('hello world')
+  expect.soft(errorListener).not.toHaveBeenCalled()
+})
+
+it('intercepts an http request with chunked request body', async () => {
+  const requestChunks: Array<string> = []
+  const errorListener = vi.fn()
+
+  interceptor.on('connection', ({ socket }) => {
+    socket.on('error', errorListener)
+    socket.on('write', (chunk) => requestChunks.push(chunk.toString()))
+    socket.push('HTTP/1.1 200 OK\r\n\r\n')
+    socket.push('hello world')
+    socket.push(null)
+  })
+
+  const request = http.request('http://localhost/resource', { method: 'POST' })
+  request.write('request')
+  request.end('body')
+  const { res, text } = await waitForClientRequest(request)
+
+  expect.soft(requestChunks.join('\r\n')).toBe(
+    `POST /resource HTTP/1.1\r
+Host: localhost\r
+Connection: close\r
+Transfer-Encoding: chunked\r
+\r
+7\r
+\r
+\r
+request\r
+\r
+\r
+4\r
+\r
+\r
+body\r
+\r
+\r
+0\r
+\r
+`
+  )
+
+  expect.soft(res.statusCode).toBe(200)
+  await expect.soft(text()).resolves.toBe('hello world')
+  expect.soft(errorListener).not.toHaveBeenCalled()
+})