@mswjs/interceptors 0.17.6 → 0.18.0

package/src/glossary.ts

@@ -1,27 +1,14 @@
-import type { HeadersObject, Headers } from 'headers-polyfill'
-import type { InteractiveIsomorphicRequest } from './InteractiveIsomorphicRequest'
-import type { IsomorphicRequest } from './IsomorphicRequest'
+import type { InteractiveRequest } from './utils/toInteractiveRequest'
 
 export const IS_PATCHED_MODULE: unique symbol = Symbol('isPatchedModule')
 
 export type RequestCredentials = 'omit' | 'include' | 'same-origin'
 
-export interface IsomorphicResponse {
-  status: number
-  statusText: string
-  headers: Headers
-  body?: string
-}
-
-export interface MockedResponse
-  extends Omit<Partial<IsomorphicResponse>, 'headers'> {
-  headers?: HeadersObject
-}
-
 export type HttpRequestEventMap = {
-  request(request: InteractiveIsomorphicRequest): Promise<void> | void
+  request(request: InteractiveRequest, requestId: string): Promise<void> | void
   response(
-    request: IsomorphicRequest,
-    response: IsomorphicResponse
+    response: Response,
+    request: Request,
+    requestId: string
   ): Promise<void> | void
 }

package/src/index.ts

@@ -1,8 +1,6 @@
 export * from './glossary'
 export * from './Interceptor'
 export * from './BatchInterceptor'
-export * from './IsomorphicRequest'
-export * from './InteractiveIsomorphicRequest'
 
 /* Utils */
 export { getCleanUrl } from './utils/getCleanUrl'

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

@@ -4,6 +4,7 @@
 import { debug } from 'debug'
 import * as express from 'express'
 import { HttpServer } from '@open-draft/test-server/http'
+import { Response } from '@remix-run/web-fetch'
 import { NodeClientRequest } from './NodeClientRequest'
 import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
@@ -49,13 +50,14 @@ test('gracefully finishes the request when it has a mocked response', (done) =>
   )
 
   emitter.on('request', (request) => {
-    request.respondWith({
-      status: 301,
-      headers: {
-        'x-custom-header': 'yes',
-      },
-      body: 'mocked-response',
-    })
+    request.respondWith(
+      new Response('mocked-response', {
+        status: 301,
+        headers: {
+          'x-custom-header': 'yes',
+        },
+      })
+    )
   })
 
   request.on('response', async (response) => {
@@ -88,10 +90,7 @@ test('responds with a mocked response when requesting an existing hostname', (do
   )
 
   emitter.on('request', (request) => {
-    request.respondWith({
-      status: 201,
-      body: 'mocked-response',
-    })
+    request.respondWith(new Response('mocked-response', { status: 201 }))
   })
 
   request.on('response', async (response) => {
@@ -183,10 +182,9 @@ test('does not emit ENOTFOUND error connecting to an inactive server given mocke
 
   emitter.on('request', async (request) => {
     await sleep(250)
-    request.respondWith({
-      status: 200,
-      statusText: 'Works',
-    })
+    request.respondWith(
+      new Response(null, { status: 200, statusText: 'Works' })
+    )
   })
 
   request.on('error', handleError)
@@ -212,10 +210,9 @@ test('does not emit ECONNREFUSED error connecting to an inactive server given mo
 
   emitter.on('request', async (request) => {
     await sleep(250)
-    request.respondWith({
-      status: 200,
-      statusText: 'Works',
-    })
+    request.respondWith(
+      new Response(null, { status: 200, statusText: 'Works' })
+    )
   })
 
   request.on('error', handleError)
@@ -272,10 +269,7 @@ test('does not send request body to the original server given mocked response',
 
   emitter.on('request', async (request) => {
     await sleep(200)
-    request.respondWith({
-      status: 301,
-      body: 'mock created!',
-    })
+    request.respondWith(new Response('mock created!', { status: 301 }))
   })
 
   request.write('one')

package/src/interceptors/ClientRequest/NodeClientRequest.ts

@@ -1,27 +1,22 @@
 import type { Debugger } from 'debug'
-import type { RequestOptions } from 'http'
 import { ClientRequest, IncomingMessage } from 'http'
 import { until } from '@open-draft/until'
-import { Headers, objectToHeaders } from 'headers-polyfill'
-import { MockedResponse } from '../../glossary'
 import type { ClientRequestEmitter } from '.'
-import { concatChunkToBuffer } from './utils/concatChunkToBuffer'
 import {
+  ClientRequestEndCallback,
   ClientRequestEndChunk,
   normalizeClientRequestEndArgs,
 } from './utils/normalizeClientRequestEndArgs'
 import { NormalizedClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { toIsoResponse } from '../../utils/toIsoResponse'
-import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
-import { bodyBufferToString } from './utils/bodyBufferToString'
 import {
   ClientRequestWriteArgs,
   normalizeClientRequestWriteArgs,
 } from './utils/normalizeClientRequestWriteArgs'
 import { cloneIncomingMessage } from './utils/cloneIncomingMessage'
-import { IsomorphicRequest } from '../../IsomorphicRequest'
-import { InteractiveIsomorphicRequest } from '../../InteractiveIsomorphicRequest'
-import { getArrayBuffer } from '../../utils/bufferUtils'
+import { createResponse } from './utils/createResponse'
+import { createRequest } from './utils/createRequest'
+import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
+import { uuidv4 } from '../../utils/uuid'
 
 export type Protocol = 'http' | 'https'
 
@@ -42,8 +37,6 @@ export class NodeClientRequest extends ClientRequest {
     'EAI_AGAIN',
   ]
 
-  private url: URL
-  private options: RequestOptions
   private response: IncomingMessage
   private emitter: ClientRequestEmitter
   private log: Debugger
@@ -54,7 +47,8 @@ export class NodeClientRequest extends ClientRequest {
   private responseSource: 'mock' | 'bypass' = 'mock'
   private capturedError?: NodeJS.ErrnoException
 
-  public requestBody: Buffer[] = []
+  public url: URL
+  public requestBuffer: Buffer | null
 
   constructor(
     [url, requestOptions, callback]: NormalizedClientRequestArgs,
@@ -73,19 +67,44 @@ export class NodeClientRequest extends ClientRequest {
     })
 
     this.url = url
-    this.options = requestOptions
     this.emitter = options.emitter
 
+    // Set request buffer to null by default so that GET/HEAD requests
+    // without a body wouldn't suddenly get one.
+    this.requestBuffer = null
+
     // Construct a mocked response message.
     this.response = new IncomingMessage(this.socket!)
   }
 
+  private writeRequestBodyChunk(
+    chunk: string | Buffer | null,
+    encoding?: BufferEncoding
+  ): void {
+    if (chunk == null) {
+      return
+    }
+
+    if (this.requestBuffer == null) {
+      this.requestBuffer = Buffer.from([])
+    }
+
+    const resolvedChunk = Buffer.isBuffer(chunk)
+      ? chunk
+      : Buffer.from(chunk, encoding)
+
+    this.requestBuffer = Buffer.concat([this.requestBuffer, resolvedChunk])
+  }
+
   write(...args: ClientRequestWriteArgs): boolean {
     const [chunk, encoding, callback] = normalizeClientRequestWriteArgs(args)
     this.log('write:', { chunk, encoding, callback })
     this.chunks.push({ chunk, encoding })
-    this.requestBody = concatChunkToBuffer(chunk, this.requestBody)
-    this.log('chunk successfully stored!', this.requestBody)
+
+    // Write each request body chunk to the internal buffer.
+    this.writeRequestBodyChunk(chunk, encoding)
+
+    this.log('chunk successfully stored!', this.requestBuffer?.byteLength)
 
     /**
      * Prevent invoking the callback if the written chunk is empty.
@@ -106,14 +125,25 @@ export class NodeClientRequest extends ClientRequest {
   end(...args: any): this {
     this.log('end', args)
 
+    const requestId = uuidv4()
+
     const [chunk, encoding, callback] = normalizeClientRequestEndArgs(...args)
     this.log('normalized arguments:', { chunk, encoding, callback })
 
-    const requestBody = this.getRequestBody(chunk)
-    const isomorphicRequest = this.toIsomorphicRequest(requestBody)
-    const interactiveIsomorphicRequest = new InteractiveIsomorphicRequest(
-      isomorphicRequest
-    )
+    // Write the last request body chunk passed to the "end()" method.
+    this.writeRequestBodyChunk(chunk, encoding || undefined)
+
+    const capturedRequest = createRequest(this)
+    const interactiveRequest = toInteractiveRequest(capturedRequest)
+
+    // Prevent handling this request if it has already been handled
+    // in another (parent) interceptor (like XMLHttpRequest -> ClientRequest).
+    // That means some interceptor up the chain has concluded that
+    // this request must be performed as-is.
+    if (this.getHeader('X-Request-Id') != null) {
+      this.removeHeader('X-Request-Id')
+      return this.passthrough(chunk, encoding, callback)
+    }
 
     // Notify the interceptor about the request.
     // This will call any "request" listeners the users have.
@@ -121,23 +151,25 @@ export class NodeClientRequest extends ClientRequest {
       'emitting the "request" event for %d listener(s)...',
       this.emitter.listenerCount('request')
     )
-    this.emitter.emit('request', interactiveIsomorphicRequest)
+    this.emitter.emit('request', interactiveRequest, requestId)
 
     // Execute the resolver Promise like a side-effect.
     // Node.js 16 forces "ClientRequest.end" to be synchronous and return "this".
     until(async () => {
-      await this.emitter.untilIdle('request', ({ args: [request] }) => {
-        /**
-         * @note Await only those listeners that are relevant to this request.
-         * This prevents extraneous parallel request from blocking the resolution
-         * of another, unrelated request. For example, during response patching,
-         * when request resolution is nested.
-         */
-        return request.id === interactiveIsomorphicRequest.id
-      })
+      await this.emitter.untilIdle(
+        'request',
+        ({ args: [, pendingRequestId] }) => {
+          /**
+           * @note Await only those listeners that are relevant to this request.
+           * This prevents extraneous parallel request from blocking the resolution
+           * of another, unrelated request. For example, during response patching,
+           * when request resolution is nested.
+           */
+          return pendingRequestId === requestId
+        }
+      )
 
-      const [mockedResponse] =
-        await interactiveIsomorphicRequest.respondWith.invoked()
+      const [mockedResponse] = await interactiveRequest.respondWith.invoked()
       this.log('event.respondWith called with:', mockedResponse)
 
       return mockedResponse
@@ -156,96 +188,54 @@ export class NodeClientRequest extends ClientRequest {
         return this
       }
 
+      // Forward any request headers that the "request" listener
+      // may have modified before proceeding with this request.
+      for (const [headerName, headerValue] of capturedRequest.headers) {
+        this.setHeader(headerName, headerValue)
+      }
+
       if (mockedResponse) {
+        const responseClone = mockedResponse.clone()
+
         this.log('received mocked response:', mockedResponse)
         this.responseSource = 'mock'
 
-        const isomorphicResponse = toIsoResponse(mockedResponse)
         this.respondWith(mockedResponse)
-        this.log(
-          isomorphicResponse.status,
-          isomorphicResponse.statusText,
-          isomorphicResponse.body,
-          '(MOCKED)'
-        )
+        this.log(mockedResponse.status, mockedResponse.statusText, '(MOCKED)')
 
         callback?.()
 
         this.log('emitting the custom "response" event...')
+        this.emitter.emit('response', responseClone, capturedRequest, requestId)
 
-        this.emitter.emit('response', isomorphicRequest, isomorphicResponse)
+        this.log('request (mock) is completed')
 
         return this
       }
 
       this.log('no mocked response received!')
 
-      // Set the response source to "bypass".
-      // Any errors emitted past this point are not suppressed.
-      this.responseSource = 'bypass'
-
-      // Propagate previously captured errors.
-      // For example, a ECONNREFUSED error when connecting to a non-existing host.
-      if (this.capturedError) {
-        this.emit('error', this.capturedError)
-        return this
-      }
-
-      // Write the request body chunks in the order of ".write()" calls.
-      // Note that no request body has been written prior to this point
-      // in order to prevent the Socket to communicate with a potentially
-      // existing server.
-      this.log('writing request chunks...', this.chunks)
-
-      for (const { chunk, encoding } of this.chunks) {
-        if (encoding) {
-          super.write(chunk, encoding)
-        } else {
-          super.write(chunk)
-        }
-      }
-
-      this.once('error', (error) => {
-        this.log('original request error:', error)
-      })
-
-      this.once('abort', () => {
-        this.log('original request aborted!')
-      })
-
-      this.once('response-internal', async (response: IncomingMessage) => {
-        const responseBody = await getIncomingMessageBody(response)
-        this.log(response.statusCode, response.statusMessage, responseBody)
-        this.log('original response headers:', response.headers)
+      this.once('response-internal', (message: IncomingMessage) => {
+        this.log(message.statusCode, message.statusMessage)
+        this.log('original response headers:', message.headers)
 
         this.log('emitting the custom "response" event...')
-        this.emitter.emit('response', isomorphicRequest, {
-          status: response.statusCode || 200,
-          statusText: response.statusMessage || 'OK',
-          headers: objectToHeaders(response.headers),
-          body: responseBody,
-        })
+        this.emitter.emit(
+          'response',
+          createResponse(message),
+          capturedRequest,
+          requestId
+        )
       })
 
-      this.log('performing original request...')
-
-      return super.end(
-        ...[
-          chunk,
-          encoding as any,
-          () => {
-            this.log('original request end!')
-            callback?.()
-          },
-        ].filter(Boolean)
-      )
+      return this.passthrough(chunk, encoding, callback)
     })
 
     return this
   }
 
   emit(event: string, ...data: any[]) {
-    this.log('event:%s', event)
+    this.log('emit: %s', event)
 
     if (event === 'response') {
       this.log('found "response" event, cloning the response...')
@@ -299,7 +289,65 @@ export class NodeClientRequest extends ClientRequest {
     return super.emit(event, ...data)
   }
 
-  private respondWith(mockedResponse: MockedResponse): void {
+  /**
+   * Performs the intercepted request as-is.
+   * Replays the captured request body chunks,
+   * still emits the internal events, and wraps
+   * up the request with `super.end()`.
+   */
+  private passthrough(
+    chunk: ClientRequestEndChunk | null,
+    encoding?: BufferEncoding | null,
+    callback?: ClientRequestEndCallback | null
+  ): this {
+    // Set the response source to "bypass".
+    // Any errors emitted past this point are not suppressed.
+    this.responseSource = 'bypass'
+
+    // Propagate previously captured errors.
+    // For example, a ECONNREFUSED error when connecting to a non-existing host.
+    if (this.capturedError) {
+      this.emit('error', this.capturedError)
+      return this
+    }
+
+    this.log('writing request chunks...', this.chunks)
+
+    // Write the request body chunks in the order of ".write()" calls.
+    // Note that no request body has been written prior to this point
+    // in order to prevent the Socket to communicate with a potentially
+    // existing server.
+    for (const { chunk, encoding } of this.chunks) {
+      if (encoding) {
+        super.write(chunk, encoding)
+      } else {
+        super.write(chunk)
+      }
+    }
+
+    this.once('error', (error) => {
+      this.log('original request error:', error)
+    })
+
+    this.once('abort', () => {
+      this.log('original request aborted!')
+    })
+
+    this.once('response-internal', (message: IncomingMessage) => {
+      this.log(message.statusCode, message.statusMessage)
+      this.log('original response headers:', message.headers)
+    })
+
+    this.log('performing original request...')
+
+    // This call signature is way too dynamic.
+    return super.end(...[chunk, encoding as any, callback].filter(Boolean))
+  }
+
+  /**
+   * Responds to this request instance using a mocked response.
+   */
+  private respondWith(mockedResponse: Response): void {
     this.log('responding with a mocked response...', mockedResponse)
 
     const { status, statusText, headers, body } = mockedResponse
@@ -309,29 +357,48 @@ export class NodeClientRequest extends ClientRequest {
     if (headers) {
       this.response.headers = {}
 
-      for (const [headerName, headerValue] of Object.entries(headers)) {
-        this.response.rawHeaders.push(
-          headerName,
-          ...(Array.isArray(headerValue) ? headerValue : [headerValue])
-        )
+      headers.forEach((headerValue, headerName) => {
+        /**
+         * @note Make sure that multi-value headers are appended correctly.
+         */
+        this.response.rawHeaders.push(headerName, headerValue)
 
         const insensitiveHeaderName = headerName.toLowerCase()
         const prevHeaders = this.response.headers[insensitiveHeaderName]
         this.response.headers[insensitiveHeaderName] = prevHeaders
           ? Array.prototype.concat([], prevHeaders, headerValue)
           : headerValue
-      }
+      })
     }
     this.log('mocked response headers ready:', headers)
 
-    if (body) {
-      this.response.push(Buffer.from(body))
+    const closeResponseStream = () => {
+      // Push "null" to indicate that the response body is complete
+      // and shouldn't be written to anymore.
+      this.response.push(null)
+      this.response.complete = true
     }
 
-    // Push "null" to indicate that the response body is complete
-    // and shouldn't be written to anymore.
-    this.response.push(null)
-    this.response.complete = true
+    if (body) {
+      const bodyReader = body.getReader()
+      const readNextChunk = async (): Promise<void> => {
+        const { done, value } = await bodyReader.read()
+
+        if (done) {
+          closeResponseStream()
+          return
+        }
+
+        // this.response.push(Buffer.from(body))
+        this.response.push(value)
+
+        return readNextChunk()
+      }
+
+      readNextChunk()
+    } else {
+      closeResponseStream()
+    }
 
     /**
      * Set the internal "res" property to the mocked "OutgoingMessage"
@@ -360,47 +427,4 @@ export class NodeClientRequest extends ClientRequest {
     // @ts-ignore
     this.agent.destroy()
   }
-
-  private getRequestBody(chunk: ClientRequestEndChunk | null): ArrayBuffer {
-    const writtenRequestBody = bodyBufferToString(
-      Buffer.concat(this.requestBody)
-    )
-    this.log('written request body:', writtenRequestBody)
-
-    // Write the last request body chunk to the internal request body buffer.
-    if (chunk) {
-      this.requestBody = concatChunkToBuffer(chunk, this.requestBody)
-    }
-
-    const resolvedRequestBody = Buffer.concat(this.requestBody)
-    this.log('resolved request body:', resolvedRequestBody)
-
-    return getArrayBuffer(resolvedRequestBody)
-  }
-
-  private toIsomorphicRequest(body: ArrayBuffer): IsomorphicRequest {
-    this.log('creating isomorphic request object...')
-
-    const outgoingHeaders = this.getHeaders()
-    this.log('request outgoing headers:', outgoingHeaders)
-
-    const headers = new Headers()
-    for (const [headerName, headerValue] of Object.entries(outgoingHeaders)) {
-      if (!headerValue) {
-        continue
-      }
-
-      headers.set(headerName.toLowerCase(), headerValue.toString())
-    }
-
-    const isomorphicRequest = new IsomorphicRequest(this.url, {
-      body,
-      method: this.options.method || 'GET',
-      credentials: 'same-origin',
-      headers,
-    })
-
-    this.log('successfully created isomorphic request!', isomorphicRequest)
-    return isomorphicRequest
-  }
 }

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

@@ -1,5 +1,6 @@
 import * as http from 'http'
 import { HttpServer } from '@open-draft/test-server/http'
+import { Response } from '@remix-run/web-fetch'
 import { ClientRequestInterceptor } from '.'
 
 const httpServer = new HttpServer((app) => {
@@ -15,7 +16,6 @@ const interceptor = new ClientRequestInterceptor()
 
 beforeAll(async () => {
   await httpServer.listen()
-
   interceptor.apply()
 })
 
@@ -28,11 +28,13 @@ it('forbids calling "respondWith" multiple times for the same request', (done) =
   const requestUrl = httpServer.http.url('/')
 
   interceptor.on('request', (request) => {
-    request.respondWith({ status: 200 })
+    request.respondWith(new Response())
   })
 
   interceptor.on('request', (request) => {
-    expect(() => request.respondWith({ status: 301 })).toThrow(
+    expect(() =>
+      request.respondWith(new Response(null, { status: 301 }))
+    ).toThrow(
       `Failed to respond to "GET ${requestUrl}" request: the "request" event has already been responded to.`
     )
 

package/src/interceptors/ClientRequest/index.ts

@@ -1,23 +1,15 @@
 import http from 'http'
 import https from 'https'
-import { invariant } from 'outvariant'
-import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
+import { HttpRequestEventMap } from '../../glossary'
 import { Interceptor } from '../../Interceptor'
 import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { get } from './http.get'
 import { request } from './http.request'
 import { NodeClientOptions, Protocol } from './NodeClientRequest'
 
-export type MaybePatchedModule<Module> = Module & {
-  [IS_PATCHED_MODULE]?: boolean
-}
-
 export type ClientRequestEmitter = AsyncEventEmitter<HttpRequestEventMap>
 
-export type ClientRequestModules = Map<
-  Protocol,
-  MaybePatchedModule<typeof http> | MaybePatchedModule<typeof https>
->
+export type ClientRequestModules = Map<Protocol, typeof http | typeof https>
 
 /**
  * Intercept requests made via the `ClientRequest` class.
@@ -41,17 +33,7 @@ export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
     for (const [protocol, requestModule] of this.modules) {
       const { request: pureRequest, get: pureGet } = requestModule
 
-      invariant(
-        !requestModule[IS_PATCHED_MODULE],
-        'Failed to patch the "%s" module: already patched.',
-        protocol
-      )
-
       this.subscriptions.push(() => {
-        Object.defineProperty(requestModule, IS_PATCHED_MODULE, {
-          value: undefined,
-        })
-
         requestModule.request = pureRequest
         requestModule.get = pureGet
 
@@ -73,12 +55,6 @@ export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
         // Force a line break.
         get(protocol, options)
 
-      Object.defineProperty(requestModule, IS_PATCHED_MODULE, {
-        configurable: true,
-        enumerable: true,
-        value: true,
-      })
-
       log('native "%s" module patched!', protocol)
     }
   }