@depup/mswjs__interceptors 0.41.3-depup.0

package/src/interceptors/ClientRequest/agents.ts

@@ -0,0 +1,110 @@
+/**
+ * Here's how requests are handled in Node.js:
+ *
+ * 1. http.ClientRequest instance calls `agent.addRequest(request, options, cb)`.
+ * 2. Agent creates a new socket: `agent.createSocket(options, cb)`.
+ * 3. Agent creates a new connection: `agent.createConnection(options, cb)`.
+ */
+import net from 'node:net'
+import http from 'node:http'
+import https from 'node:https'
+import {
+  MockHttpSocket,
+  type MockHttpSocketRequestCallback,
+  type MockHttpSocketResponseCallback,
+} from './MockHttpSocket'
+
+declare module 'node:http' {
+  interface Agent {
+    options?: http.AgentOptions
+    createConnection(options: any, callback: any): net.Socket
+  }
+}
+
+interface MockAgentOptions {
+  customAgent?: http.RequestOptions['agent']
+  onRequest: MockHttpSocketRequestCallback
+  onResponse: MockHttpSocketResponseCallback
+}
+
+export class MockAgent extends http.Agent {
+  private customAgent?: http.RequestOptions['agent']
+  private onRequest: MockHttpSocketRequestCallback
+  private onResponse: MockHttpSocketResponseCallback
+
+  constructor(options: MockAgentOptions) {
+    super()
+    this.customAgent = options.customAgent
+    this.onRequest = options.onRequest
+    this.onResponse = options.onResponse
+  }
+
+  public createConnection(options: any, callback: any): net.Socket {
+    const createConnection =
+      this.customAgent instanceof http.Agent
+        ? this.customAgent.createConnection
+        : super.createConnection
+
+    const createConnectionOptions =
+      this.customAgent instanceof http.Agent
+        ? {
+            ...options,
+            ...this.customAgent.options,
+          }
+        : options
+
+    const socket = new MockHttpSocket({
+      connectionOptions: options,
+      createConnection: createConnection.bind(
+        this.customAgent || this,
+        createConnectionOptions,
+        callback
+      ),
+      onRequest: this.onRequest.bind(this),
+      onResponse: this.onResponse.bind(this),
+    })
+
+    return socket
+  }
+}
+
+export class MockHttpsAgent extends https.Agent {
+  private customAgent?: https.RequestOptions['agent']
+  private onRequest: MockHttpSocketRequestCallback
+  private onResponse: MockHttpSocketResponseCallback
+
+  constructor(options: MockAgentOptions) {
+    super()
+    this.customAgent = options.customAgent
+    this.onRequest = options.onRequest
+    this.onResponse = options.onResponse
+  }
+
+  public createConnection(options: any, callback: any): net.Socket {
+    const createConnection =
+      this.customAgent instanceof http.Agent
+        ? this.customAgent.createConnection
+        : super.createConnection
+
+    const createConnectionOptions =
+      this.customAgent instanceof http.Agent
+        ? {
+            ...options,
+            ...this.customAgent.options,
+          }
+        : options
+
+    const socket = new MockHttpSocket({
+      connectionOptions: options,
+      createConnection: createConnection.bind(
+        this.customAgent || this,
+        createConnectionOptions,
+        callback
+      ),
+      onRequest: this.onRequest.bind(this),
+      onResponse: this.onResponse.bind(this),
+    })
+
+    return socket
+  }
+}

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

@@ -0,0 +1,75 @@
+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 { ClientRequestInterceptor } from '.'
+import { sleep, waitForClientRequest } 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')
+  })
+})
+
+const interceptor = new ClientRequestInterceptor()
+
+beforeAll(async () => {
+  interceptor.apply()
+  await httpServer.listen()
+})
+
+afterEach(() => {
+  interceptor.removeAllListeners()
+})
+
+afterAll(async () => {
+  interceptor.dispose()
+  await httpServer.close()
+})
+
+it('abort the request if the abort signal is emitted', async () => {
+  const requestUrl = httpServer.http.url('/')
+
+  interceptor.on('request', async function delayedResponse({ controller }) {
+    await sleep(1_000)
+    controller.respondWith(new Response())
+  })
+
+  const abortController = new AbortController()
+  const request = http.get(requestUrl, { signal: abortController.signal })
+
+  abortController.abort()
+
+  const abortErrorPromise = new DeferredPromise<Error>()
+  request.on('error', function (error) {
+    abortErrorPromise.resolve(error)
+  })
+
+  const abortError = await abortErrorPromise
+  expect(abortError.name).toEqual('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

@@ -0,0 +1,193 @@
+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'
+
+export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol = Symbol('client-request-interceptor')
+
+  constructor() {
+    super(ClientRequestInterceptor.symbol)
+  }
+
+  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()
+
+    this.subscriptions.push(() => {
+      http.ClientRequest = OriginalClientRequest
+
+      http.get = originalGet
+      http.request = originalRequest
+
+      https.get = originalHttpsGet
+      https.request = originalHttpsRequest
+
+      restoreHeadersPrototype()
+    })
+  }
+
+  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)
+        }
+      },
+    })
+
+    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,
+    })
+  }
+}

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

@@ -0,0 +1,54 @@
+import { it, expect } from 'vitest'
+import { IncomingMessage } from 'http'
+import { Socket } from 'net'
+import * as zlib from 'zlib'
+import { getIncomingMessageBody } from './getIncomingMessageBody'
+
+it('returns utf8 string given a utf8 response body', async () => {
+  const utfBuffer = Buffer.from('one')
+  const message = new IncomingMessage(new Socket())
+
+  const pendingResponseBody = getIncomingMessageBody(message)
+  message.emit('data', utfBuffer)
+  message.emit('end')
+
+  expect(await pendingResponseBody).toEqual('one')
+})
+
+it('returns utf8 string given a gzipped response body', async () => {
+  const utfBuffer = zlib.gzipSync(Buffer.from('two'))
+  const message = new IncomingMessage(new Socket())
+  message.headers = {
+    'content-encoding': 'gzip',
+  }
+
+  const pendingResponseBody = getIncomingMessageBody(message)
+  message.emit('data', utfBuffer)
+  message.emit('end')
+
+  expect(await pendingResponseBody).toEqual('two')
+})
+
+it('returns utf8 string given a gzipped response body with incorrect "content-length"', async () => {
+  const utfBuffer = zlib.gzipSync(Buffer.from('three'))
+  const message = new IncomingMessage(new Socket())
+  message.headers = {
+    'content-encoding': 'gzip',
+    'content-length': '500',
+  }
+
+  const pendingResponseBody = getIncomingMessageBody(message)
+  message.emit('data', utfBuffer)
+  message.emit('end')
+
+  expect(await pendingResponseBody).toEqual('three')
+})
+
+it('returns empty string given an empty body', async () => {
+  const message = new IncomingMessage(new Socket())
+
+  const pendingResponseBody = getIncomingMessageBody(message)
+  message.emit('end')
+
+  expect(await pendingResponseBody).toEqual('')
+})

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

@@ -0,0 +1,45 @@
+import { IncomingMessage } from 'http'
+import { PassThrough } from 'stream'
+import * as zlib from 'zlib'
+import { Logger } from '@open-draft/logger'
+
+const logger = new Logger('http getIncomingMessageBody')
+
+export function getIncomingMessageBody(
+  response: IncomingMessage
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    logger.info('cloning the original response...')
+
+    // Pipe the original response to support non-clone
+    // "response" input. No need to clone the response,
+    // as we always have access to the full "response" input,
+    // either a clone or an original one (in tests).
+    const responseClone = response.pipe(new PassThrough())
+    const stream =
+      response.headers['content-encoding'] === 'gzip'
+        ? responseClone.pipe(zlib.createGunzip())
+        : responseClone
+
+    const encoding = response.readableEncoding || 'utf8'
+    stream.setEncoding(encoding)
+    logger.info('using encoding:', encoding)
+
+    let body = ''
+
+    stream.on('data', (responseBody) => {
+      logger.info('response body read:', responseBody)
+      body += responseBody
+    })
+
+    stream.once('end', () => {
+      logger.info('response body end')
+      resolve(body)
+    })
+
+    stream.once('error', (error) => {
+      logger.info('error while reading response body:', error)
+      reject(error)
+    })
+  })
+}