@mswjs/interceptors 0.32.2 → 0.33.1

package/src/RemoteHttpInterceptor.ts

@@ -4,8 +4,8 @@ import { Interceptor } from './Interceptor'
 import { BatchInterceptor } from './BatchInterceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
-import { toInteractiveRequest } from './utils/toInteractiveRequest'
-import { emitAsync } from './utils/emitAsync'
+import { handleRequest } from './utils/handleRequest'
+import { RequestController } from './RequestController'
 
 export interface SerializedRequest {
   id: string
@@ -46,7 +46,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
 
     let handleParentMessage: NodeJS.MessageListener
 
-    this.on('request', async ({ request, requestId }) => {
+    this.on('request', async ({ request, requestId, controller }) => {
       // Send the stringified intercepted request to
       // the parent process where the remote resolver is established.
       const serializedRequest = JSON.stringify({
@@ -64,6 +64,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
         'sent serialized request to the child:',
         serializedRequest
       )
+
       process.send?.(`request:${serializedRequest}`)
 
       const responsePromise = new Promise<void>((resolve) => {
@@ -90,7 +91,12 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
               headers: responseInit.headers,
             })
 
-            request.respondWith(mockedResponse)
+            /**
+             * @todo Support "errorWith" as well.
+             * This response handling from the child is incomplete.
+             */
+
+            controller.respondWith(mockedResponse)
             return resolve()
           }
         }
@@ -158,69 +164,68 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
         serializedRequest,
         requestReviver
       ) as RevivedRequest
+
       logger.info('parsed intercepted request', requestJson)
 
-      const capturedRequest = new Request(requestJson.url, {
+      const request = new Request(requestJson.url, {
         method: requestJson.method,
         headers: new Headers(requestJson.headers),
         credentials: requestJson.credentials,
         body: requestJson.body,
       })
 
-      const { interactiveRequest, requestController } =
-        toInteractiveRequest(capturedRequest)
-
-      this.emitter.once('request', () => {
-        if (requestController.responsePromise.state === 'pending') {
-          requestController.respondWith(undefined)
-        }
-      })
-
-      await emitAsync(this.emitter, 'request', {
-        request: interactiveRequest,
+      const controller = new RequestController(request)
+      await handleRequest({
+        request,
         requestId: requestJson.id,
+        controller,
+        emitter: this.emitter,
+        onResponse: async (response) => {
+          this.logger.info('received mocked response!', { response })
+
+          const responseClone = response.clone()
+          const responseText = await responseClone.text()
+
+          // // Send the mocked response to the child process.
+          const serializedResponse = JSON.stringify({
+            status: response.status,
+            statusText: response.statusText,
+            headers: Array.from(response.headers.entries()),
+            body: responseText,
+          } as SerializedResponse)
+
+          this.process.send(
+            `response:${requestJson.id}:${serializedResponse}`,
+            (error) => {
+              if (error) {
+                return
+              }
+
+              // Emit an optimistic "response" event at this point,
+              // not to rely on the back-and-forth signaling for the sake of the event.
+              this.emitter.emit('response', {
+                request,
+                requestId: requestJson.id,
+                response: responseClone,
+                isMockedResponse: true,
+              })
+            }
+          )
+
+          logger.info(
+            'sent serialized mocked response to the parent:',
+            serializedResponse
+          )
+        },
+        onRequestError: (response) => {
+          this.logger.info('received a network error!', { response })
+          throw new Error('Not implemented')
+        },
+        onError: (error) => {
+          this.logger.info('request has errored!', { error })
+          throw new Error('Not implemented')
+        },
       })
-
-      const mockedResponse = await requestController.responsePromise
-
-      if (!mockedResponse) {
-        return
-      }
-
-      logger.info('event.respondWith called with:', mockedResponse)
-      const responseClone = mockedResponse.clone()
-      const responseText = await mockedResponse.text()
-
-      // Send the mocked response to the child process.
-      const serializedResponse = JSON.stringify({
-        status: mockedResponse.status,
-        statusText: mockedResponse.statusText,
-        headers: Array.from(mockedResponse.headers.entries()),
-        body: responseText,
-      } as SerializedResponse)
-
-      this.process.send(
-        `response:${requestJson.id}:${serializedResponse}`,
-        (error) => {
-          if (error) {
-            return
-          }
-
-          // Emit an optimistic "response" event at this point,
-          // not to rely on the back-and-forth signaling for the sake of the event.
-          this.emitter.emit('response', {
-            response: responseClone,
-            isMockedResponse: true,
-            request: capturedRequest,
-            requestId: requestJson.id,
-          })
-        }
-      )
-
-      logger.info(
-        'sent serialized mocked response to the parent:',
-        serializedResponse
-      )
     }
 
     this.subscriptions.push(() => {

package/src/RequestController.test.ts

@@ -0,0 +1,49 @@
+import { it, expect } from 'vitest'
+import { kResponsePromise, RequestController } from './RequestController'
+
+it('creates a pending response promise on construction', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  expect(controller[kResponsePromise]).toBeInstanceOf(Promise)
+  expect(controller[kResponsePromise].state).toBe('pending')
+})
+
+it('resolves the response promise with the response provided to "respondWith"', async () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.respondWith(new Response('hello world'))
+
+  const response = (await controller[kResponsePromise]) as Response
+
+  expect(response).toBeInstanceOf(Response)
+  expect(response.status).toBe(200)
+  expect(await response.text()).toBe('hello world')
+})
+
+it('resolves the response promise with the error provided to "errorWith"', async () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  const error = new Error('Oops!')
+  controller.errorWith(error)
+
+  await expect(controller[kResponsePromise]).resolves.toEqual(error)
+})
+
+it('throws when calling "respondWith" multiple times', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.respondWith(new Response('hello world'))
+
+  expect(() => {
+    controller.respondWith(new Response('second response'))
+  }).toThrow(
+    'Failed to respond to the "GET http://localhost/" request: the "request" event has already been handled.'
+  )
+})
+
+it('throws when calling "errorWith" multiple times', () => {
+  const controller = new RequestController(new Request('http://localhost'))
+  controller.errorWith(new Error('Oops!'))
+
+  expect(() => {
+    controller.errorWith(new Error('second error'))
+  }).toThrow(
+    'Failed to error the "GET http://localhost/" request: the "request" event has already been handled.'
+  )
+})

package/src/RequestController.ts

@@ -0,0 +1,81 @@
+import { invariant } from 'outvariant'
+import { DeferredPromise } from '@open-draft/deferred-promise'
+import { InterceptorError } from './InterceptorError'
+
+const kRequestHandled = Symbol('kRequestHandled')
+export const kResponsePromise = Symbol('kResponsePromise')
+
+export class RequestController {
+  /**
+   * Internal response promise.
+   * Available only for the library internals to grab the
+   * response instance provided by the developer.
+   * @note This promise cannot be rejected. It's either infinitely
+   * pending or resolved with whichever Response was passed to `respondWith()`.
+   */
+  [kResponsePromise]: DeferredPromise<Response | Error | undefined>;
+
+  /**
+   * Internal flag indicating if this request has been handled.
+   * @note The response promise becomes "fulfilled" on the next tick.
+   */
+  [kRequestHandled]: boolean
+
+  constructor(private request: Request) {
+    this[kRequestHandled] = false
+    this[kResponsePromise] = new DeferredPromise()
+  }
+
+  /**
+   * Respond to this request with the given `Response` instance.
+   * @example
+   * controller.respondWith(new Response())
+   * controller.respondWith(Response.json({ id }))
+   * controller.respondWith(Response.error())
+   */
+  public respondWith(response: Response): void {
+    invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to respond to the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    )
+
+    this[kRequestHandled] = true
+    this[kResponsePromise].resolve(response)
+
+    /**
+     * @note The request conrtoller doesn't do anything
+     * apart from letting the interceptor await the response
+     * provided by the developer through the response promise.
+     * Each interceptor implements the actual respondWith/errorWith
+     * logic based on that interceptor's needs.
+     */
+  }
+
+  /**
+   * Error this request with the given error.
+   * @example
+   * controller.errorWith()
+   * controller.errorWith(new Error('Oops!'))
+   */
+  public errorWith(error?: Error): void {
+    invariant.as(
+      InterceptorError,
+      !this[kRequestHandled],
+      'Failed to error the "%s %s" request: the "request" event has already been handled.',
+      this.request.method,
+      this.request.url
+    )
+
+    this[kRequestHandled] = true
+
+    /**
+     * @note Resolve the response promise, not reject.
+     * This helps us differentiate between unhandled exceptions
+     * and intended errors ("errorWith") while waiting for the response.
+     */
+    this[kResponsePromise].resolve(error)
+  }
+}

package/src/glossary.ts

@@ -1,4 +1,4 @@
-import type { InteractiveRequest } from './utils/toInteractiveRequest'
+import type { RequestController } from './RequestController'
 
 export const IS_PATCHED_MODULE: unique symbol = Symbol('isPatchedModule')
 
@@ -7,8 +7,9 @@ export type RequestCredentials = 'omit' | 'include' | 'same-origin'
 export type HttpRequestEventMap = {
   request: [
     args: {
-      request: InteractiveRequest
+      request: Request
       requestId: string
+      controller: RequestController
     }
   ]
   response: [
@@ -24,10 +25,7 @@ export type HttpRequestEventMap = {
       error: unknown
       request: Request
       requestId: string
-      controller: {
-        respondWith(response: Response): void
-        errorWith(error?: Error): void
-      }
+      controller: RequestController
     }
   ]
 }

package/src/interceptors/ClientRequest/MockHttpSocket.ts

@@ -378,7 +378,7 @@ export class MockHttpSocket extends MockSocket {
   /**
    * Close this socket connection with the given error.
    */
-  public errorWith(error: Error): void {
+  public errorWith(error?: Error): void {
     this.destroy(error)
   }
 

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

@@ -3,7 +3,7 @@ import http from 'node:http'
 import { HttpServer } from '@open-draft/test-server/http'
 import { DeferredPromise } from '@open-draft/deferred-promise'
 import { ClientRequestInterceptor } from '.'
-import { sleep } from '../../../test/helpers'
+import { sleep, waitForClientRequest } from '../../../test/helpers'
 
 const httpServer = new HttpServer((app) => {
   app.get('/', (_req, res) => {
@@ -30,43 +30,12 @@ afterAll(async () => {
   await httpServer.close()
 })
 
-it('forbids calling "respondWith" multiple times for the same request', async () => {
-  const requestUrl = httpServer.http.url('/')
-
-  interceptor.on('request', function firstRequestListener({ request }) {
-    request.respondWith(new Response())
-  })
-
-  const secondRequestEmitted = new DeferredPromise<void>()
-  interceptor.on('request', function secondRequestListener({ request }) {
-    expect(() =>
-      request.respondWith(new Response(null, { status: 301 }))
-    ).toThrow(
-      `Failed to respond to "GET ${requestUrl}" request: the "request" event has already been responded to.`
-    )
-
-    secondRequestEmitted.resolve()
-  })
-
-  const request = http.get(requestUrl)
-  await secondRequestEmitted
-
-  const responseReceived = new DeferredPromise<http.IncomingMessage>()
-  request.on('response', (response) => {
-    responseReceived.resolve(response)
-  })
-
-  const response = await responseReceived
-  expect(response.statusCode).toBe(200)
-  expect(response.statusMessage).toBe('OK')
-})
-
 it('abort the request if the abort signal is emitted', async () => {
   const requestUrl = httpServer.http.url('/')
 
-  interceptor.on('request', async function delayedResponse({ request }) {
+  interceptor.on('request', async function delayedResponse({ controller }) {
     await sleep(1_000)
-    request.respondWith(new Response())
+    controller.respondWith(new Response())
   })
 
   const abortController = new AbortController()
@@ -84,3 +53,23 @@ it('abort the request if the abort signal is emitted', async () => {
 
   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,6 +1,5 @@
 import http from 'node:http'
 import https from 'node:https'
-import { until } from '@open-draft/until'
 import { Interceptor } from '../../Interceptor'
 import type { HttpRequestEventMap } from '../../glossary'
 import {
@@ -9,11 +8,10 @@ import {
   MockHttpSocketResponseCallback,
 } from './MockHttpSocket'
 import { MockAgent, MockHttpsAgent } from './agents'
+import { RequestController } from '../../RequestController'
 import { emitAsync } from '../../utils/emitAsync'
-import { toInteractiveRequest } from '../../utils/toInteractiveRequest'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
-import { isNodeLikeError } from '../../utils/isNodeLikeError'
-import { createServerErrorResponse } from '../../utils/responseUtils'
+import { handleRequest } from '../../utils/handleRequest'
 import {
   recordRawFetchHeaders,
   restoreHeadersPrototype,
@@ -129,88 +127,29 @@ export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
     socket,
   }) => {
     const requestId = Reflect.get(request, kRequestId)
-    const { interactiveRequest, requestController } =
-      toInteractiveRequest(request)
-
-    // TODO: Abstract this bit. We are using it everywhere.
-    this.emitter.once('request', ({ requestId: pendingRequestId }) => {
-      if (pendingRequestId !== requestId) {
-        return
-      }
-
-      if (requestController.responsePromise.state === 'pending') {
-        this.logger.info(
-          'request has not been handled in listeners, executing fail-safe listener...'
-        )
-
-        requestController.responsePromise.resolve(undefined)
-      }
-    })
+    const controller = new RequestController(request)
 
-    const listenerResult = await until(async () => {
-      await emitAsync(this.emitter, 'request', {
-        requestId,
-        request: interactiveRequest,
-      })
-
-      return await requestController.responsePromise
-    })
-
-    if (listenerResult.error) {
-      // Treat thrown Responses as mocked responses.
-      if (listenerResult.error instanceof Response) {
-        socket.respondWith(listenerResult.error)
-        return
-      }
-
-      // Allow mocking Node-like errors.
-      if (isNodeLikeError(listenerResult.error)) {
-        socket.errorWith(listenerResult.error)
-        return
-      }
-
-      // Emit the "unhandledException" event to allow the client
-      //  to opt-out from the default handling of exceptions
-      // as 500 error responses.
-      if (this.emitter.listenerCount('unhandledException') > 0) {
-        await emitAsync(this.emitter, 'unhandledException', {
-          error: listenerResult.error,
-          request,
-          requestId,
-          controller: {
-            respondWith: socket.respondWith.bind(socket),
-            errorWith: socket.errorWith.bind(socket),
-          },
-        })
-
-        // After the listeners are done, if the socket is
-        // not connecting anymore, the response was mocked.
-        // If the socket has been destroyed, the error was mocked.
-        // Treat both as the result of the listener's call.
-        if (!socket.connecting || socket.destroyed) {
-          return
+    const isRequestHandled = await handleRequest({
+      request,
+      requestId,
+      controller,
+      emitter: this.emitter,
+      onResponse: (response) => {
+        socket.respondWith(response)
+      },
+      onRequestError: (response) => {
+        socket.respondWith(response)
+      },
+      onError: (error) => {
+        if (error instanceof Error) {
+          socket.errorWith(error)
         }
-      }
-
-      // Unhandled exceptions in the request listeners are
-      // synonymous to unhandled exceptions on the server.
-      // Those are represented as 500 error responses.
-      socket.respondWith(createServerErrorResponse(listenerResult.error))
-      return
-    }
-
-    const mockedResponse = listenerResult.data
+      },
+    })
 
-    if (mockedResponse) {
-      /**
-       * @note The `.respondWith()` method will handle "Response.error()".
-       * Maybe we should make all interceptors do that?
-       */
-      socket.respondWith(mockedResponse)
-      return
+    if (!isRequestHandled) {
+      return socket.passthrough()
     }
-
-    socket.passthrough()
   }
 
   public onResponse: MockHttpSocketResponseCallback = async ({