@mswjs/interceptors 0.32.2 → 0.33.1

package/src/interceptors/ClientRequest/utils/recordRawHeaders.test.ts

@@ -0,0 +1,159 @@
+// @vitest-environment node
+import { it, expect, afterEach } from 'vitest'
+import {
+  recordRawFetchHeaders,
+  restoreHeadersPrototype,
+  getRawFetchHeaders,
+} from './recordRawHeaders'
+
+const url = 'http://localhost'
+
+afterEach(() => {
+  restoreHeadersPrototype()
+})
+
+it('returns an empty list if no headers were set', () => {
+  expect(getRawFetchHeaders(new Headers())).toEqual([])
+  expect(getRawFetchHeaders(new Headers(undefined))).toEqual([])
+  expect(getRawFetchHeaders(new Headers({}))).toEqual([])
+  expect(getRawFetchHeaders(new Headers([]))).toEqual([])
+  expect(getRawFetchHeaders(new Request(url).headers)).toEqual([])
+  expect(getRawFetchHeaders(new Response().headers)).toEqual([])
+})
+
+it('records raw headers (Headers / object as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers({
+    'Content-Type': 'application/json',
+    'X-My-Header': '1',
+  })
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+  expect(Object.fromEntries(headers)).toEqual({
+    'content-type': 'application/json',
+    'x-my-header': '1',
+  })
+})
+
+it('records raw headers (Headers / array as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+
+  expect(getRawFetchHeaders(headers)).toEqual([['X-My-Header', '1']])
+  expect(Object.fromEntries(headers)).toEqual({
+    'x-my-header': '1',
+  })
+})
+
+it('records raw headers (Headers / Headers as init', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+
+  expect(getRawFetchHeaders(new Headers(headers))).toEqual([
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers added via ".set()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.set('X-Another-Header', '2')
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['X-My-Header', '1'],
+    ['X-Another-Header', '2'],
+  ])
+})
+
+it('records raw headers added via ".append()"', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.append('X-My-Header', '2')
+
+  expect(getRawFetchHeaders(headers)).toEqual([
+    ['X-My-Header', '1'],
+    ['X-My-Header', '2'],
+  ])
+})
+
+it('deletes the header when called ".delete()"', () => {
+  const headers = new Headers([['X-My-Header', '1']])
+  headers.delete('X-My-Header')
+
+  expect(getRawFetchHeaders(headers)).toEqual([])
+})
+
+it('records raw headers (Request / object as init)', () => {
+  recordRawFetchHeaders()
+  const request = new Request(url, {
+    headers: {
+      'Content-Type': 'application/json',
+      'X-My-Header': '1',
+    },
+  })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers (Request / array as init)', () => {
+  recordRawFetchHeaders()
+  const request = new Request(url, {
+    headers: [['X-My-Header', '1']],
+  })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Request / Headers as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  const request = new Request(url, { headers })
+
+  expect(getRawFetchHeaders(request.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Response / object as init)', () => {
+  recordRawFetchHeaders()
+  const response = new Response(null, {
+    headers: {
+      'Content-Type': 'application/json',
+      'X-My-Header': '1',
+    },
+  })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([
+    ['Content-Type', 'application/json'],
+    ['X-My-Header', '1'],
+  ])
+})
+
+it('records raw headers (Response / array as init)', () => {
+  recordRawFetchHeaders()
+  const response = new Response(null, {
+    headers: [['X-My-Header', '1']],
+  })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('records raw headers (Response / Headers as init)', () => {
+  recordRawFetchHeaders()
+  const headers = new Headers([['X-My-Header', '1']])
+  const response = new Response(null, { headers })
+
+  expect(getRawFetchHeaders(response.headers)).toEqual([['X-My-Header', '1']])
+})
+
+it('stops recording once the patches are restored', () => {
+  restoreHeadersPrototype()
+
+  const headers = new Headers({ 'X-My-Header': '1' })
+  // Must return the normalized headers (no access to raw headers).
+  expect(getRawFetchHeaders(headers)).toEqual([['x-my-header', '1']])
+})

package/src/interceptors/ClientRequest/utils/recordRawHeaders.ts

@@ -5,16 +5,24 @@ const kRawHeaders = Symbol('kRawHeaders')
 const kRestorePatches = Symbol('kRestorePatches')
 
 function recordRawHeader(headers: Headers, args: HeaderTuple) {
-  if (Reflect.get(headers, kRawHeaders) == null) {
-    Object.defineProperty(headers, kRawHeaders, {
-      value: [],
-      enumerable: false,
-    })
+  if (!Reflect.has(headers, kRawHeaders)) {
+    defineRawHeaders(headers, [])
   }
   const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders
   rawHeaders.push(args)
 }
 
+function defineRawHeaders(headers: Headers, rawHeaders: RawHeaders): void {
+  if (Reflect.has(headers, kRawHeaders)) {
+    return
+  }
+
+  Object.defineProperty(headers, kRawHeaders, {
+    value: rawHeaders,
+    enumerable: false,
+  })
+}
+
 /**
  * Patch the global `Headers` class to store raw headers.
  * This is for compatibility with `IncomingMessage.prototype.rawHeaders`.
@@ -35,7 +43,11 @@ export function recordRawFetchHeaders() {
     return Reflect.get(Headers, kRestorePatches)
   }
 
-  const { Request: OriginalRequest, Response: OriginalResponse } = globalThis
+  const {
+    Headers: OriginalHeaders,
+    Request: OriginalRequest,
+    Response: OriginalResponse,
+  } = globalThis
   const { set, append, delete: headersDeleteMethod } = Headers.prototype
 
   Object.defineProperty(Headers, kRestorePatches, {
@@ -43,30 +55,49 @@ export function recordRawFetchHeaders() {
       Headers.prototype.set = set
       Headers.prototype.append = append
       Headers.prototype.delete = headersDeleteMethod
+      globalThis.Headers = OriginalHeaders
 
       globalThis.Request = OriginalRequest
       globalThis.Response = OriginalResponse
+
+      Reflect.deleteProperty(Headers, kRestorePatches)
     },
     enumerable: false,
+    /**
+     * @note Mark this property as configurable
+     * so we can delete it using `Reflect.delete` during cleanup.
+     */
+    configurable: true,
   })
 
   Headers = new Proxy(Headers, {
     construct(target, args, newTarget) {
+      const headersInit = args[0] || []
+
+      if (
+        headersInit instanceof Headers &&
+        Reflect.has(headersInit, kRawHeaders)
+      ) {
+        const headers = Reflect.construct(
+          target,
+          [Reflect.get(headersInit, kRawHeaders)],
+          newTarget
+        )
+        defineRawHeaders(headers, Reflect.get(headersInit, kRawHeaders))
+        return headers
+      }
+
       const headers = Reflect.construct(target, args, newTarget)
-      const initialHeaders = args[0] || []
-      const initialRawHeaders = Array.isArray(initialHeaders)
-        ? initialHeaders
-        : Object.entries(initialHeaders)
 
       // Request/Response constructors will set the symbol
       // upon creating a new instance, using the raw developer
       // input as the raw headers. Skip the symbol altogether
       // in those cases because the input to Headers will be normalized.
       if (!Reflect.has(headers, kRawHeaders)) {
-        Object.defineProperty(headers, kRawHeaders, {
-          value: initialRawHeaders,
-          enumerable: false,
-        })
+        const rawHeadersInit = Array.isArray(headersInit)
+          ? headersInit
+          : Object.entries(headersInit)
+        defineRawHeaders(headers, rawHeadersInit)
       }
 
       return headers
@@ -105,14 +136,27 @@ export function recordRawFetchHeaders() {
 
   Request = new Proxy(Request, {
     construct(target, args, newTarget) {
-      const request = Reflect.construct(target, args, newTarget)
-
+      /**
+       * @note If the headers init argument of Request
+       * is existing Headers instance, use its raw headers
+       * as the headers init instead.
+       * This is needed because the Headers constructor copies
+       * all normalized headers from the given Headers instance
+       * and uses ".append()" to add it to the new instance.
+       */
       if (
         typeof args[1] === 'object' &&
         args[1].headers != null &&
-        !request.headers[kRawHeaders]
+        args[1].headers instanceof Headers &&
+        Reflect.has(args[1].headers, kRawHeaders)
       ) {
-        request.headers[kRawHeaders] = inferRawHeaders(args[1].headers)
+        args[1].headers = args[1].headers[kRawHeaders]
+      }
+
+      const request = Reflect.construct(target, args, newTarget)
+
+      if (typeof args[1] === 'object' && args[1].headers != null) {
+        defineRawHeaders(request.headers, inferRawHeaders(args[1].headers))
       }
 
       return request
@@ -121,15 +165,19 @@ export function recordRawFetchHeaders() {
 
   Response = new Proxy(Response, {
     construct(target, args, newTarget) {
+      if (
+        typeof args[1] === 'object' &&
+        args[1].headers != null &&
+        args[1].headers instanceof Headers &&
+        Reflect.has(args[1].headers, kRawHeaders)
+      ) {
+        args[1].headers = args[1].headers[kRawHeaders]
+      }
+
       const response = Reflect.construct(target, args, newTarget)
 
       if (typeof args[1] === 'object' && args[1].headers != null) {
-        /**
-         * @note Pass the init argument directly because it gets
-         * transformed into a normalized Headers instance once it
-         * passes the Response constructor.
-         */
-        response.headers[kRawHeaders] = inferRawHeaders(args[1].headers)
+        defineRawHeaders(response.headers, inferRawHeaders(args[1].headers))
       }
 
       return response
@@ -146,9 +194,14 @@ export function restoreHeadersPrototype() {
 }
 
 export function getRawFetchHeaders(headers: Headers): RawHeaders {
-  // Return the raw headers, if recorded (i.e. `.set()` or `.append()` was called).
-  // If no raw headers were recorded, return all the headers.
-  return Reflect.get(headers, kRawHeaders) || Array.from(headers.entries())
+  // If the raw headers recording failed for some reason,
+  // use the normalized header entries instead.
+  if (!Reflect.has(headers, kRawHeaders)) {
+    return Array.from(headers.entries())
+  }
+
+  const rawHeaders = Reflect.get(headers, kRawHeaders) as RawHeaders
+  return rawHeaders.length > 0 ? rawHeaders : Array.from(headers.entries())
 }
 
 /**

package/src/interceptors/XMLHttpRequest/XMLHttpRequestController.ts

@@ -481,7 +481,7 @@ export class XMLHttpRequestController {
     return null
   }
 
-  public errorWith(error: Error): void {
+  public errorWith(error?: Error): void {
     this.logger.info('responding with an error')
 
     this.setReadyState(this.request.DONE)

package/src/interceptors/XMLHttpRequest/XMLHttpRequestProxy.ts

@@ -1,13 +1,8 @@
-import { until } from '@open-draft/until'
 import type { Logger } from '@open-draft/logger'
 import { XMLHttpRequestEmitter } from '.'
-import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
-import { emitAsync } from '../../utils/emitAsync'
+import { RequestController } from '../../RequestController'
 import { XMLHttpRequestController } from './XMLHttpRequestController'
-import {
-  createServerErrorResponse,
-  isResponseError,
-} from '../../utils/responseUtils'
+import { handleRequest } from '../../utils/handleRequest'
 
 export interface XMLHttpRequestProxyOptions {
   emitter: XMLHttpRequestEmitter
@@ -57,116 +52,40 @@ export function createXMLHttpRequestProxy({
       )
 
       xhrRequestController.onRequest = async function ({ request, requestId }) {
-        const { interactiveRequest, requestController } =
-          toInteractiveRequest(request)
+        const controller = new RequestController(request)
 
         this.logger.info('awaiting mocked response...')
 
-        emitter.once('request', ({ requestId: pendingRequestId }) => {
-          if (pendingRequestId !== requestId) {
-            return
-          }
-
-          if (requestController.responsePromise.state === 'pending') {
-            requestController.respondWith(undefined)
-          }
-        })
-
-        const resolverResult = await until(async () => {
-          this.logger.info(
-            'emitting the "request" event for %s listener(s)...',
-            emitter.listenerCount('request')
-          )
-
-          await emitAsync(emitter, 'request', {
-            request: interactiveRequest,
-            requestId,
-          })
-
-          this.logger.info('all "request" listeners settled!')
-
-          const mockedResponse = await requestController.responsePromise
-
-          this.logger.info('event.respondWith called with:', mockedResponse)
-
-          return mockedResponse
-        })
-
-        if (resolverResult.error) {
-          this.logger.info(
-            'request listener threw an exception, aborting request...',
-            resolverResult.error
-          )
-
-          // Treat thrown Responses as mocked responses.
-          if (resolverResult.error instanceof Response) {
-            if (isResponseError(resolverResult.error)) {
-              xhrRequestController.errorWith(new TypeError('Network error'))
-            } else {
-              this.respondWith(resolverResult.error)
-            }
-
-            return
-          }
-
-          if (emitter.listenerCount('unhandledException') > 0) {
-            // Emit the "unhandledException" event so the client can opt-out
-            // from the default exception handling (producing 500 error responses).
-            await emitAsync(emitter, 'unhandledException', {
-              error: resolverResult.error,
-              request,
-              requestId,
-              controller: {
-                respondWith:
-                  xhrRequestController.respondWith.bind(xhrRequestController),
-                errorWith:
-                  xhrRequestController.errorWith.bind(xhrRequestController),
-              },
-            })
+        this.logger.info(
+          'emitting the "request" event for %s listener(s)...',
+          emitter.listenerCount('request')
+        )
 
-            // If any of the "unhandledException" listeners handled the request,
-            // do nothing. Note that mocked responses will dispatch
-            // HEADERS_RECEIVED (2), then LOADING (3), and DONE (4) can take
-            // time as the mocked response body finishes streaming.
-            if (originalRequest.readyState > XMLHttpRequest.OPENED) {
-              return
+        const isRequestHandled = await handleRequest({
+          request,
+          requestId,
+          controller,
+          emitter,
+          onResponse: (response) => {
+            this.respondWith(response)
+          },
+          onRequestError: () => {
+            this.errorWith(new TypeError('Network error'))
+          },
+          onError: (error) => {
+            this.logger.info('request errored!', { error })
+
+            if (error instanceof Error) {
+              this.errorWith(error)
             }
-          }
-
-          // Unhandled exceptions in the request listeners are
-          // synonymous to unhandled exceptions on the server.
-          // Those are represented as 500 error responses.
-          xhrRequestController.respondWith(
-            createServerErrorResponse(resolverResult.error)
-          )
-
-          return
-        }
-
-        const mockedResponse = resolverResult.data
+          },
+        })
 
-        if (typeof mockedResponse !== 'undefined') {
+        if (!isRequestHandled) {
           this.logger.info(
-            'received mocked response: %d %s',
-            mockedResponse.status,
-            mockedResponse.statusText
+            'no mocked response received, performing request as-is...'
           )
-
-          if (isResponseError(mockedResponse)) {
-            this.logger.info(
-              'received a network error response, rejecting the request promise...'
-            )
-
-            xhrRequestController.errorWith(new TypeError('Network error'))
-            return
-          }
-
-          return xhrRequestController.respondWith(mockedResponse)
         }
-
-        this.logger.info(
-          'no mocked response received, performing request as-is...'
-        )
       }
 
       xhrRequestController.onResponse = async function ({

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,15 +1,9 @@
 import { invariant } from 'outvariant'
 import { Emitter } from 'strict-event-emitter'
 import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
-import { InteractiveRequest } from '../../utils/toInteractiveRequest'
 import { Interceptor } from '../../Interceptor'
 import { createXMLHttpRequestProxy } from './XMLHttpRequestProxy'
 
-export type XMLHttpRequestEventListener = (args: {
-  request: InteractiveRequest
-  requestId: string
-}) => Promise<void> | void
-
 export type XMLHttpRequestEmitter = Emitter<HttpRequestEventMap>
 
 export class XMLHttpRequestInterceptor extends Interceptor<HttpRequestEventMap> {