@mswjs/interceptors 0.41.9 → 0.42.1

package/src/interceptors/ClientRequest/index.test.ts

@@ -1,24 +1,26 @@
-import { it, expect, beforeAll, afterEach, afterAll } from 'vitest'
-import http from 'node:http'
-import { HttpServer } from '@open-draft/test-server/http'
-import { DeferredPromise } from '@open-draft/deferred-promise'
+import * as http from 'node:http'
+import { setTimeout } from 'node:timers/promises'
+import {
+  createTestHttpServer,
+  type TestHttpServer,
+} from '@epic-web/test-server/http'
 import { ClientRequestInterceptor } from '.'
-import { sleep, waitForClientRequest } from '../../../test/helpers'
+import { toWebResponse } from '../../../test/helpers'
 
-const httpServer = new HttpServer((app) => {
-  app.get('/', (_req, res) => {
-    res.status(200).send('/')
-  })
-  app.get('/get', (_req, res) => {
-    res.status(200).send('/get')
-  })
-})
+let httpServer: TestHttpServer
 
 const interceptor = new ClientRequestInterceptor()
 
 beforeAll(async () => {
   interceptor.apply()
-  await httpServer.listen()
+  httpServer = await createTestHttpServer({
+    defineRoutes(router) {
+      // The test server always defines a root ("/") route.
+      router.get('/get', () => {
+        return new Response('/get')
+      })
+    },
+  })
 })
 
 afterEach(() => {
@@ -31,10 +33,10 @@ afterAll(async () => {
 })
 
 it('abort the request if the abort signal is emitted', async () => {
-  const requestUrl = httpServer.http.url('/')
+  const requestUrl = httpServer.http.url('/').href
 
   interceptor.on('request', async function delayedResponse({ controller }) {
-    await sleep(1_000)
+    await setTimeout(1000)
     controller.respondWith(new Response())
   })
 
@@ -43,33 +45,13 @@ it('abort the request if the abort signal is emitted', async () => {
 
   abortController.abort()
 
-  const abortErrorPromise = new DeferredPromise<Error>()
+  const abortErrorPromise = Promise.withResolvers<Error>()
   request.on('error', function (error) {
     abortErrorPromise.resolve(error)
   })
 
-  const abortError = await abortErrorPromise
-  expect(abortError.name).toEqual('AbortError')
+  const abortError = await abortErrorPromise.promise
+  expect(abortError.name).toBe('AbortError')
 
   expect(request.destroyed).toBe(true)
 })
-
-it('patch the Headers object correctly after dispose and reapply', async () => {
-  interceptor.dispose()
-  interceptor.apply()
-
-  interceptor.on('request', ({ controller }) => {
-    const headers = new Headers({
-      'X-CustoM-HeadeR': 'Yes',
-    })
-    controller.respondWith(new Response(null, { headers }))
-  })
-
-  const request = http.get(httpServer.http.url('/'))
-  const { res } = await waitForClientRequest(request)
-
-  expect(res.rawHeaders).toEqual(
-    expect.arrayContaining(['X-CustoM-HeadeR', 'Yes'])
-  )
-  expect(res.headers['x-custom-header']).toEqual('Yes')
-})

package/src/interceptors/ClientRequest/index.ts

@@ -1,193 +1,78 @@
 import http from 'node:http'
 import https from 'node:https'
-import { Interceptor } from '../../Interceptor'
-import type { HttpRequestEventMap } from '../../glossary'
-import {
-  kRequestId,
-  MockHttpSocketRequestCallback,
-  MockHttpSocketResponseCallback,
-} from './MockHttpSocket'
-import { MockAgent, MockHttpsAgent } from './agents'
-import { RequestController } from '../../RequestController'
-import { emitAsync } from '../../utils/emitAsync'
-import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { handleRequest } from '../../utils/handleRequest'
-import {
-  recordRawFetchHeaders,
-  restoreHeadersPrototype,
-} from './utils/recordRawHeaders'
-
+import { runInRequestContext } from '#/src/request-context'
+import { patchesRegistry } from '#/src/utils/patches-registry'
+import { forwardHttpEvents } from '#/src/interceptors/http/forward-events'
+import { NodeHttpRequestSource } from '#/src/interceptors/http/source'
+import { Interceptor } from '../../interceptor'
+import { HttpRequestEventMap } from '#/src/events/http'
+
+/**
+ * Interceptor for HTTP requests in Node.js made via `http.ClientRequest`.
+ */
 export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
   static symbol = Symbol.for('client-request-interceptor')
 
-  constructor() {
-    super(ClientRequestInterceptor.symbol)
+  protected predicate(): boolean {
+    return true
   }
 
   protected setup(): void {
-    const {
-      ClientRequest: OriginalClientRequest,
-      get: originalGet,
-      request: originalRequest,
-    } = http
-    const { get: originalHttpsGet, request: originalHttpsRequest } = https
-
-    const onRequest = this.onRequest.bind(this)
-    const onResponse = this.onResponse.bind(this)
-
-    // Support requests performed via the `ClientRequest` constructor directly.
-    http.ClientRequest = new Proxy(http.ClientRequest, {
-      construct: (target, args: Parameters<typeof http.request>) => {
-        const [url, options, callback] = normalizeClientRequestArgs(
-          'http:',
-          args
-        )
-
-        // Create a mock agent instance appropriate for the request protocol.
-        const Agent = options.protocol === 'https:' ? MockHttpsAgent : MockAgent
-        const mockAgent = new Agent({
-          customAgent: options.agent,
-          onRequest,
-          onResponse,
-        })
-        options.agent = mockAgent
-
-        return Reflect.construct(target, [url, options, callback])
-      },
-    })
-
-    http.request = new Proxy(http.request, {
-      apply: (target, thisArg, args: Parameters<typeof http.request>) => {
-        const [url, options, callback] = normalizeClientRequestArgs(
-          'http:',
-          args
-        )
-        const mockAgent = new MockAgent({
-          customAgent: options.agent,
-          onRequest,
-          onResponse,
-        })
-        options.agent = mockAgent
-
-        return Reflect.apply(target, thisArg, [url, options, callback])
-      },
-    })
-
-    http.get = new Proxy(http.get, {
-      apply: (target, thisArg, args: Parameters<typeof http.get>) => {
-        const [url, options, callback] = normalizeClientRequestArgs(
-          'http:',
-          args
-        )
-
-        const mockAgent = new MockAgent({
-          customAgent: options.agent,
-          onRequest,
-          onResponse,
-        })
-        options.agent = mockAgent
-
-        return Reflect.apply(target, thisArg, [url, options, callback])
-      },
-    })
-
-    //
-    // HTTPS.
-    //
-
-    https.request = new Proxy(https.request, {
-      apply: (target, thisArg, args: Parameters<typeof https.request>) => {
-        const [url, options, callback] = normalizeClientRequestArgs(
-          'https:',
-          args
-        )
-
-        const mockAgent = new MockHttpsAgent({
-          customAgent: options.agent,
-          onRequest,
-          onResponse,
-        })
-        options.agent = mockAgent
-
-        return Reflect.apply(target, thisArg, [url, options, callback])
-      },
-    })
-
-    https.get = new Proxy(https.get, {
-      apply: (target, thisArg, args: Parameters<typeof https.get>) => {
-        const [url, options, callback] = normalizeClientRequestArgs(
-          'https:',
-          args
-        )
-
-        const mockAgent = new MockHttpsAgent({
-          customAgent: options.agent,
-          onRequest,
-          onResponse,
-        })
-        options.agent = mockAgent
-
-        return Reflect.apply(target, thisArg, [url, options, callback])
-      },
-    })
-
-    // Spy on `Header.prototype.set` and `Header.prototype.append` calls
-    // and record the raw header names provided. This is to support
-    // `IncomingMessage.prototype.rawHeaders`.
-    recordRawFetchHeaders()
-
+    const requestSource = Interceptor.singleton(NodeHttpRequestSource)
+    const requestLogger = this.logger
+    requestSource.apply(this)
     this.subscriptions.push(() => {
-      http.ClientRequest = OriginalClientRequest
-
-      http.get = originalGet
-      http.request = originalRequest
-
-      https.get = originalHttpsGet
-      https.request = originalHttpsRequest
-
-      restoreHeadersPrototype()
+      requestSource.dispose(this)
     })
-  }
 
-  private onRequest: MockHttpSocketRequestCallback = async ({
-    request,
-    socket,
-  }) => {
-    const controller = new RequestController(request, {
-      passthrough() {
-        socket.passthrough()
-      },
-      async respondWith(response) {
-        await socket.respondWith(response)
-      },
-      errorWith(reason) {
-        if (reason instanceof Error) {
-          socket.errorWith(reason)
+    this.subscriptions.push(
+      forwardHttpEvents({
+        source: requestSource,
+        emitter: this.emitter,
+        predicate: (initiator) => {
+          return initiator instanceof http.ClientRequest
+        },
+      })
+    )
+
+    this.subscriptions.push(
+      patchesRegistry.applyPatch(http, 'ClientRequest', (ClientRequest) => {
+        return new Proxy(ClientRequest, {
+          construct(target, args, newTarget) {
+            return runInRequestContext(() => {
+              return Reflect.construct(target, args, newTarget)
+            }, requestLogger)
+          },
+        })
+      }),
+      patchesRegistry.applyPatch(http, 'get', (httpGet) => {
+        return function mockHttpGet(...args) {
+          return runInRequestContext(() => {
+            return httpGet(...(args as [any, any]))
+          }, requestLogger)
         }
-      },
-    })
-
-    await handleRequest({
-      request,
-      requestId: Reflect.get(request, kRequestId),
-      controller,
-      emitter: this.emitter,
-    })
-  }
-
-  public onResponse: MockHttpSocketResponseCallback = async ({
-    requestId,
-    request,
-    response,
-    isMockedResponse,
-  }) => {
-    // Return the promise to when all the response event listeners
-    // are finished.
-    return emitAsync(this.emitter, 'response', {
-      requestId,
-      request,
-      response,
-      isMockedResponse,
-    })
+      }),
+      patchesRegistry.applyPatch(http, 'request', (httpRequest) => {
+        return function mockHttpRequest(...args) {
+          return runInRequestContext(() => {
+            return httpRequest(...(args as [any, any]))
+          }, requestLogger)
+        }
+      }),
+      patchesRegistry.applyPatch(https, 'get', (httpsGet) => {
+        return function mockHttpsGet(...args) {
+          return runInRequestContext(() => {
+            return httpsGet(...(args as [any, any]))
+          }, requestLogger)
+        }
+      }),
+      patchesRegistry.applyPatch(https, 'request', (httpsRequest) => {
+        return function mockHttpsRequest(...args) {
+          return runInRequestContext(() => {
+            return httpsRequest(...(args as [any, any]))
+          }, requestLogger)
+        }
+      })
+    )
   }
 }

package/src/interceptors/ClientRequest/utils/{recordRawHeaders.test.ts → record-raw-headers.test.ts}

@@ -1,10 +1,9 @@
 // @vitest-environment node
-import { it, expect, afterEach } from 'vitest'
 import {
   recordRawFetchHeaders,
   restoreHeadersPrototype,
   getRawFetchHeaders,
-} from './recordRawHeaders'
+} from './record-raw-headers'
 
 const url = 'http://localhost'
 

package/src/interceptors/ClientRequest/utils/{recordRawHeaders.ts → record-raw-headers.ts}

@@ -1,4 +1,4 @@
-import { FetchRequest, FetchResponse } from '../../../utils/fetchUtils'
+import { FetchRequest, FetchResponse } from '../../../utils/fetch-utils'
 
 type HeaderTuple = [string, string]
 type RawHeaders = Array<HeaderTuple>
@@ -71,7 +71,7 @@ function defineRawHeadersSymbol(headers: Headers, rawHeaders: RawHeaders) {
  * h.append('x-custom', 'two')
  * h[Symbol('headers map')] // Map { 'X-Custom' => 'one, two' }
  */
-export function recordRawFetchHeaders() {
+export function recordRawFetchHeaders(): () => void {
   // Prevent patching the Headers prototype multiple times.
   if (Reflect.get(Headers, kRestorePatches)) {
     return Reflect.get(Headers, kRestorePatches)
@@ -255,6 +255,8 @@ export function recordRawFetchHeaders() {
   Object.setPrototypeOf(FetchRequest.prototype, globalThis.Request.prototype)
   Object.setPrototypeOf(FetchResponse, globalThis.Response)
   Object.setPrototypeOf(FetchResponse.prototype, globalThis.Response.prototype)
+
+  return restoreHeadersPrototype
 }
 
 export function restoreHeadersPrototype() {
@@ -293,3 +295,28 @@ function inferRawHeaders(headers: HeadersInit): RawHeaders {
 
   return Reflect.get(new Headers(headers), kRawHeaders)
 }
+
+export function copyRawHeaders(source: Headers, destination: Headers): void {
+  const rawHeaders = [...getRawFetchHeaders(source)]
+
+  if (rawHeaders.length === 0) {
+    return
+  }
+
+  /**
+   * @note Add headers from trhe destination that raw headers from the source
+   * don't have. Undici automatically appends a "Content-Type" header for responses
+   * and, for some reason, that change is not recorded. This preserves it.
+   */
+  for (const [name, value] of destination) {
+    if (
+      rawHeaders.every(
+        (header) => header[0].toLowerCase() !== name.toLowerCase()
+      )
+    ) {
+      rawHeaders.push([name, value])
+    }
+  }
+
+  defineRawHeadersSymbol(destination, rawHeaders)
+}

package/src/interceptors/WebSocket/index.ts

@@ -1,29 +1,33 @@
-import { Interceptor } from '../../Interceptor'
+import { Interceptor } from '../../interceptor'
+import {
+  WebSocketConnectionEvent,
+  type WebSocketEventMap,
+} from '../../events/websocket'
 import {
   WebSocketClientConnectionProtocol,
   WebSocketClientConnection,
   type WebSocketClientEventMap,
-} from './WebSocketClientConnection'
+} from './web-socket-client-connection'
 import {
   WebSocketServerConnectionProtocol,
   WebSocketServerConnection,
   type WebSocketServerEventMap,
-} from './WebSocketServerConnection'
-import { WebSocketClassTransport } from './WebSocketClassTransport'
+} from './web-socket-server-connection'
+import { WebSocketClassTransport } from './web-socket-class-transport'
 import {
   kClose,
   kPassthroughPromise,
   WebSocketOverride,
-} from './WebSocketOverride'
-import { bindEvent } from './utils/bindEvent'
-import { hasConfigurableGlobal } from '../../utils/hasConfigurableGlobal'
-import { emitAsync } from '../../utils/emitAsync'
-import { patchesRegistry } from '../../utils/patchesRegistry'
+} from './web-socket-override'
+import { bindEvent } from './utils/bind-event'
+import { hasConfigurableGlobal } from '../../utils/has-configurable-global'
+import { patchesRegistry } from '../../utils/patches-registry'
+import { createLogger } from '../../utils/logger'
 
 export {
   type WebSocketData,
   type WebSocketTransport,
-} from './WebSocketTransport'
+} from './web-socket-transport'
 export {
   WebSocketClientEventMap,
   WebSocketClientConnectionProtocol,
@@ -39,31 +43,7 @@ export {
   CancelableMessageEvent,
 } from './utils/events'
 
-export type WebSocketEventMap = {
-  connection: [args: WebSocketConnectionData]
-}
-
-export type WebSocketConnectionData = {
-  /**
-   * The incoming WebSocket client connection.
-   */
-  client: WebSocketClientConnection
-
-  /**
-   * The original WebSocket server connection.
-   */
-  server: WebSocketServerConnection
-
-  /**
-   * The connection information.
-   */
-  info: {
-    /**
-     * The protocols supported by the WebSocket client.
-     */
-    protocols: string | Array<string> | undefined
-  }
-}
+const logger = createLogger('websocket')
 
 /**
  * Intercept the outgoing WebSocket connections created using
@@ -72,16 +52,12 @@ export type WebSocketConnectionData = {
 export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
   static symbol = Symbol.for('websocket-interceptor')
 
-  constructor() {
-    super(WebSocketInterceptor.symbol)
-  }
-
-  protected checkEnvironment(): boolean {
+  protected predicate(): boolean {
     return hasConfigurableGlobal('WebSocket')
   }
 
   protected setup(): void {
-    const logger = this.logger.extend('setup')
+    logger.verbose('setup')
 
     const WebSocketProxy = new Proxy(globalThis.WebSocket, {
       construct: (
@@ -91,6 +67,11 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
       ) => {
         const [url, protocols] = args
 
+        logger.info('connection intercepted %o', {
+          url: url.toString(),
+          protocols,
+        })
+
         const createConnection = (): WebSocket => {
           return Reflect.construct(target, args, newTarget)
         }
@@ -118,13 +99,15 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
             // The "globalThis.WebSocket" class stands for
             // the client-side connection. Assume it's established
             // as soon as the WebSocket instance is constructed.
-            await emitAsync(this.emitter, 'connection', {
-              client: new WebSocketClientConnection(socket, transport),
-              server,
-              info: {
-                protocols,
-              },
-            })
+            await this.emitter.emitAsPromise(
+              new WebSocketConnectionEvent({
+                client: new WebSocketClientConnection(socket, transport),
+                server,
+                info: {
+                  protocols,
+                },
+              })
+            )
 
             if (hasConnectionListeners) {
               socket[kPassthroughPromise].resolve(false)
@@ -173,12 +156,12 @@ export class WebSocketInterceptor extends Interceptor<WebSocketEventMap> {
       },
     })
 
-    logger.info('patching global WebSocket...')
+    logger.verbose('patching global WebSocket...')
 
     this.subscriptions.push(
       patchesRegistry.applyPatch(globalThis, 'WebSocket', () => WebSocketProxy)
     )
 
-    logger.info('global WebSocket patched!', globalThis.WebSocket.name)
+    logger.verbose('global WebSocket patched: %s', globalThis.WebSocket.name)
   }
 }

package/src/interceptors/WebSocket/utils/{bindEvent.test.ts → bind-event.test.ts}

@@ -1,8 +1,7 @@
 /**
  * @vitest-environment node
  */
-import { it, expect } from 'vitest'
-import { bindEvent } from './bindEvent'
+import { bindEvent } from './bind-event'
 
 it('sets the "target" on the given event', () => {
   class Target {}

package/src/interceptors/WebSocket/utils/events.test.ts

@@ -1,7 +1,6 @@
 /**
  * @vitest-environment node
  */
-import { describe, it, expect } from 'vitest'
 import { CancelableMessageEvent, CloseEvent } from './events'
 
 describe(CancelableMessageEvent, () => {

package/src/interceptors/WebSocket/{WebSocketClassTransport.ts → web-socket-class-transport.ts}

@@ -1,11 +1,11 @@
-import { bindEvent } from './utils/bindEvent'
+import { bindEvent } from './utils/bind-event'
 import {
   StrictEventListenerOrEventListenerObject,
   WebSocketData,
   WebSocketTransport,
   WebSocketTransportEventMap,
-} from './WebSocketTransport'
-import { kOnSend, kClose, WebSocketOverride } from './WebSocketOverride'
+} from './web-socket-transport'
+import { kOnSend, kClose, WebSocketOverride } from './web-socket-override'
 import { CancelableMessageEvent, CloseEvent } from './utils/events'
 
 /**

package/src/interceptors/WebSocket/{WebSocketClientConnection.ts → web-socket-client-connection.ts}

@@ -1,8 +1,8 @@
-import type { WebSocketData, WebSocketTransport } from './WebSocketTransport'
-import type { WebSocketEventListener } from './WebSocketOverride'
-import { bindEvent } from './utils/bindEvent'
+import type { WebSocketData, WebSocketTransport } from './web-socket-transport'
+import type { WebSocketEventListener } from './web-socket-override'
+import { bindEvent } from './utils/bind-event'
 import { CancelableMessageEvent, CloseEvent } from './utils/events'
-import { createRequestId } from '../../createRequestId'
+import { createRequestId } from '../../create-request-id'
 
 const kEmitter = Symbol('kEmitter')
 const kBoundListener = Symbol('kBoundListener')

package/src/interceptors/WebSocket/{WebSocketOverride.ts → web-socket-override.ts}

@@ -1,9 +1,8 @@
 import { invariant } from 'outvariant'
-import { DeferredPromise } from '@open-draft/deferred-promise'
-import type { WebSocketData } from './WebSocketTransport'
-import { bindEvent } from './utils/bindEvent'
+import type { WebSocketData } from './web-socket-transport'
+import { bindEvent } from './utils/bind-event'
 import { CloseEvent } from './utils/events'
-import { resolveWebSocketUrl } from '../../utils/resolveWebSocketUrl'
+import { resolveWebSocketUrl } from '../../utils/resolve-web-socket-url'
 
 export type WebSocketEventListener<
   EventType extends WebSocketEventMap[keyof WebSocketEventMap] = Event,
@@ -40,7 +39,7 @@ export class WebSocketOverride extends EventTarget implements WebSocket {
   private _onerror: WebSocketEventListener | null = null
   private _onclose: WebSocketEventListener<CloseEvent> | null = null
 
-  private [kPassthroughPromise]: DeferredPromise<boolean>
+  private [kPassthroughPromise]: PromiseWithResolvers<boolean>
   private [kOnSend]?: (data: WebSocketData) => void
 
   constructor(url: string | URL, protocols?: string | Array<string>) {
@@ -52,10 +51,10 @@ export class WebSocketOverride extends EventTarget implements WebSocket {
     this.readyState = this.CONNECTING
     this.bufferedAmount = 0
 
-    this[kPassthroughPromise] = new DeferredPromise<boolean>()
+    this[kPassthroughPromise] = Promise.withResolvers<boolean>()
 
     queueMicrotask(async () => {
-      if (await this[kPassthroughPromise]) {
+      if (await this[kPassthroughPromise].promise) {
         return
       }
 

package/src/interceptors/WebSocket/{WebSocketServerConnection.ts → web-socket-server-connection.ts}

@@ -3,10 +3,10 @@ import {
   kClose,
   WebSocketEventListener,
   WebSocketOverride,
-} from './WebSocketOverride'
-import type { WebSocketData } from './WebSocketTransport'
-import type { WebSocketClassTransport } from './WebSocketClassTransport'
-import { bindEvent } from './utils/bindEvent'
+} from './web-socket-override'
+import type { WebSocketData } from './web-socket-transport'
+import type { WebSocketClassTransport } from './web-socket-class-transport'
+import { bindEvent } from './utils/bind-event'
 import {
   CancelableMessageEvent,
   CancelableCloseEvent,

package/src/interceptors/WebSocket/{WebSocketTransport.ts → web-socket-transport.ts}

@@ -1,6 +1,6 @@
 import { CloseEvent } from './utils/events'
 
-export type WebSocketData = string | ArrayBufferLike | Blob | ArrayBufferView
+export type WebSocketData = string | ArrayBuffer | Blob | ArrayBufferView<ArrayBuffer>
 
 export type WebSocketTransportEventMap = {
   incoming: MessageEvent<WebSocketData>