@mswjs/interceptors 0.12.6 → 0.13.2

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

@@ -0,0 +1,38 @@
+import { debug } from 'debug'
+import { IncomingMessage } from 'http'
+import { PassThrough } from 'stream'
+import * as zlib from 'zlib'
+
+const log = debug('http getIncomingMessageBody')
+
+export function getIncomingMessageBody(
+  response: IncomingMessage
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    log('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)
+    log('using encoding:', encoding)
+
+    stream.once('data', (responseBody) => {
+      log('response body read:', responseBody)
+      resolve(responseBody)
+    })
+
+    stream.once('error', (error) => {
+      log('error while reading response body:', error)
+      reject(error)
+    })
+  })
+}

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

@@ -0,0 +1,336 @@
+import { parse } from 'url'
+import { Agent as HttpsAgent } from 'https'
+import { getUrlByRequestOptions } from '../../../utils/getUrlByRequestOptions'
+import { normalizeClientRequestArgs } from './normalizeClientRequestArgs'
+
+test('handles [string, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    'https://mswjs.io/resource',
+    function cb() {}
+  )
+
+  // URL string must be converted to a URL instance.
+  expect(url.href).toEqual('https://mswjs.io/resource')
+
+  // Request options must be derived from the URL instance.
+  expect(options).toHaveProperty('method', 'GET')
+  expect(options).toHaveProperty('protocol', 'https:')
+  expect(options).toHaveProperty('hostname', 'mswjs.io')
+  expect(options).toHaveProperty('path', '/resource')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [string, RequestOptions, callback] input', () => {
+  const initialOptions = {
+    headers: {
+      'Content-Type': 'text/plain',
+    },
+  }
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    'https://mswjs.io/resource',
+    initialOptions,
+    function cb() {}
+  )
+
+  // URL must be created from the string.
+  expect(url.href).toEqual('https://mswjs.io/resource')
+
+  // Request options must be preserved.
+  expect(options).toHaveProperty('headers', initialOptions.headers)
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [URL, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    new URL('https://mswjs.io/resource'),
+    function cb() {}
+  )
+
+  // URL must be preserved.
+  expect(url.href).toEqual('https://mswjs.io/resource')
+
+  // Request options must be derived from the URL instance.
+  expect(options.method).toEqual('GET')
+  expect(options.protocol).toEqual('https:')
+  expect(options.hostname).toEqual('mswjs.io')
+  expect(options.path).toEqual('/resource')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Absolute Legacy URL, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    parse('https://cherry:durian@mswjs.io:12345/resource?apple=banana'),
+    function cb() {}
+  )
+
+  // URL must be preserved.
+  expect(url.toJSON()).toEqual(
+    new URL(
+      'https://cherry:durian@mswjs.io:12345/resource?apple=banana'
+    ).toJSON()
+  )
+
+  // Request options must be derived from the URL instance.
+  expect(options.method).toEqual('GET')
+  expect(options.protocol).toEqual('https:')
+  expect(options.hostname).toEqual('mswjs.io')
+  expect(options.path).toEqual('/resource?apple=banana')
+  expect(options.port).toEqual(12345)
+  expect(options.auth).toEqual('cherry:durian')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Relative Legacy URL, RequestOptions without path set, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'http:',
+    parse('/resource?apple=banana'),
+    { host: 'mswjs.io' },
+    function cb() {}
+  )
+
+  // Correct WHATWG URL generated.
+  expect(url.toJSON()).toEqual(
+    new URL('http://mswjs.io/resource?apple=banana').toJSON()
+  )
+
+  // No path in request options, so legacy url path is copied-in.
+  expect(options.protocol).toEqual('http:')
+  expect(options.host).toEqual('mswjs.io')
+  expect(options.path).toEqual('/resource?apple=banana')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Relative Legacy URL, RequestOptions with path set, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'http:',
+    parse('/resource?apple=banana'),
+    { host: 'mswjs.io', path: '/other?cherry=durian' },
+    function cb() {}
+  )
+
+  // Correct WHATWG URL generated.
+  expect(url.toJSON()).toEqual(
+    new URL('http://mswjs.io/other?cherry=durian').toJSON()
+  )
+
+  // Path in request options, so that path is preferred.
+  expect(options.protocol).toEqual('http:')
+  expect(options.host).toEqual('mswjs.io')
+  expect(options.path).toEqual('/other?cherry=durian')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Relative Legacy URL, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'http:',
+    parse('/resource?apple=banana'),
+    function cb() {}
+  )
+
+  // Correct WHATWG URL generated.
+  expect(url.toJSON()).toMatch(
+    getUrlByRequestOptions({ path: '/resource?apple=banana' }).toJSON()
+  )
+
+  // Check path is in options.
+  expect(options.protocol).toEqual('http:')
+  expect(options.path).toEqual('/resource?apple=banana')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Relative Legacy URL] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'http:',
+    parse('/resource?apple=banana')
+  )
+
+  // Correct WHATWG URL generated.
+  expect(url.toJSON()).toMatch(
+    getUrlByRequestOptions({ path: '/resource?apple=banana' }).toJSON()
+  )
+
+  // Check path is in options.
+  expect(options.protocol).toEqual('http:')
+  expect(options.path).toEqual('/resource?apple=banana')
+
+  // Callback must be preserved.
+  expect(callback).toBeUndefined()
+})
+
+test('handles [URL, RequestOptions, callback] input', () => {
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    new URL('https://mswjs.io/resource'),
+    {
+      agent: false,
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    },
+    function cb() {}
+  )
+
+  // URL must be preserved.
+  expect(url.href).toEqual('https://mswjs.io/resource')
+
+  // Options must be preserved.
+  expect(options).toEqual({
+    agent: false,
+    protocol: url.protocol,
+    method: 'GET',
+    headers: {
+      'Content-Type': 'text/plain',
+    },
+
+    host: url.host,
+    hostname: url.hostname,
+    path: url.pathname,
+  })
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [RequestOptions, callback] input', () => {
+  const initialOptions = {
+    method: 'POST',
+    protocol: 'https:',
+    host: 'mswjs.io',
+    /**
+     * @see https://github.com/mswjs/msw/issues/705
+     */
+    origin: 'https://mswjs.io',
+    path: '/resource',
+    headers: {
+      'Content-Type': 'text/plain',
+    },
+  }
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    initialOptions,
+    function cb() {}
+  )
+
+  // URL must be derived from request options.
+  expect(url.href).toEqual('https://mswjs.io/resource')
+
+  // Request options must be preserved.
+  expect(options).toEqual(initialOptions)
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('handles [Empty RequestOptions, callback] input', () => {
+  const [_, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    {},
+    function cb() {}
+  )
+
+  expect(options.protocol).toEqual('https:')
+
+  // Callback must be preserved
+  expect(callback?.name).toEqual('cb')
+})
+
+/**
+ * @see https://github.com/mswjs/interceptors/issues/19
+ */
+test('handles [PartialRequestOptions, callback] input', () => {
+  const initialOptions = {
+    method: 'GET',
+    port: '50176',
+    path: '/resource',
+    host: '127.0.0.1',
+    ca: undefined,
+    key: undefined,
+    pfx: undefined,
+    cert: undefined,
+    passphrase: undefined,
+    agent: false,
+  }
+  const [url, options, callback] = normalizeClientRequestArgs(
+    'https:',
+    initialOptions,
+    function cb() {}
+  )
+
+  // URL must be derived from request options.
+  expect(url.toJSON()).toEqual(
+    new URL('https://127.0.0.1:50176/resource').toJSON()
+  )
+
+  // Request options must be preserved.
+  expect(options).toEqual(initialOptions)
+
+  // Options protocol must be inferred from the request issuing module.
+  expect(options.protocol).toEqual('https:')
+
+  // Callback must be preserved.
+  expect(callback?.name).toEqual('cb')
+})
+
+test('sets fallback Agent based on the URL protocol', () => {
+  const [url, options] = normalizeClientRequestArgs(
+    'https:',
+    'https://github.com'
+  )
+
+  expect(options.agent).toBeInstanceOf(HttpsAgent)
+  expect(
+    // @ts-expect-error Protocol is an internal property.
+    options.agent.protocol
+  ).toEqual(url.protocol)
+})
+
+test('does not set any fallback Agent given "agent: false" option', () => {
+  const [, options] = normalizeClientRequestArgs(
+    'https:',
+    'https://github.com',
+    { agent: false }
+  )
+
+  expect(options.agent).toEqual(false)
+})
+
+test('merges URL-based RequestOptions with the custom RequestOptions', () => {
+  const [url, options] = normalizeClientRequestArgs(
+    'https:',
+    'https://github.com/graphql',
+    {
+      method: 'GET',
+      pfx: 'PFX_KEY',
+    }
+  )
+
+  expect(url.href).toEqual('https://github.com/graphql')
+
+  // Original request options must be preserved.
+  expect(options.method).toEqual('GET')
+  expect(options.pfx).toEqual('PFX_KEY')
+
+  // Other options must be inferred from the URL.
+  expect(options.protocol).toEqual(url.protocol)
+  expect(options.host).toEqual(url.host)
+  expect(options.hostname).toEqual(url.hostname)
+  expect(options.path).toEqual(url.pathname)
+})

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

@@ -0,0 +1,205 @@
+import { debug } from 'debug'
+import { Agent as HttpAgent, IncomingMessage } from 'http'
+import { RequestOptions, Agent as HttpsAgent } from 'https'
+import { Url as LegacyURL } from 'url'
+import { getRequestOptionsByUrl } from '../../../utils/getRequestOptionsByUrl'
+import {
+  ResolvedRequestOptions,
+  getUrlByRequestOptions,
+} from '../../../utils/getUrlByRequestOptions'
+import { cloneObject } from '../../../utils/cloneObject'
+import { isObject } from '../../../utils/isObject'
+
+const log = debug('http normalizeClientRequestArgs')
+
+export type HttpRequestCallback = (response: IncomingMessage) => void
+
+export type ClientRequestArgs =
+  | [string | URL | LegacyURL, HttpRequestCallback?]
+  | [string | URL | LegacyURL, RequestOptions, HttpRequestCallback?]
+  | [RequestOptions, HttpRequestCallback?]
+
+function resolveRequestOptions(
+  args: ClientRequestArgs,
+  url: URL
+): RequestOptions {
+  // Calling `fetch` provides only URL to `ClientRequest`
+  // without any `RequestOptions` or callback.
+  if (typeof args[1] === 'undefined' || typeof args[1] === 'function') {
+    log('request options not provided, deriving from the url', url)
+    return getRequestOptionsByUrl(url)
+  }
+
+  if (args[1]) {
+    log('has custom RequestOptions!', args[1])
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url)
+
+    log('derived RequestOptions from the URL:', requestOptionsFromUrl)
+
+    /**
+     * Clone the request options to lock their state
+     * at the moment they are provided to `ClientRequest`.
+     * @see https://github.com/mswjs/interceptors/issues/86
+     */
+    log('cloning RequestOptions...')
+    const clonedRequestOptions = cloneObject(args[1])
+    log('successfully cloned RequestOptions!', clonedRequestOptions)
+
+    return {
+      ...requestOptionsFromUrl,
+      ...clonedRequestOptions,
+    }
+  }
+
+  log('using an empty object as request options')
+  return {} as RequestOptions
+}
+
+function resolveCallback(
+  args: ClientRequestArgs
+): HttpRequestCallback | undefined {
+  return typeof args[1] === 'function' ? args[1] : args[2]
+}
+
+export type NormalizedClientRequestArgs = [
+  url: URL,
+  options: ResolvedRequestOptions,
+  callback?: HttpRequestCallback
+]
+
+/**
+ * Normalizes parameters given to a `http.request` call
+ * so it always has a `URL` and `RequestOptions`.
+ */
+export function normalizeClientRequestArgs(
+  defaultProtocol: string,
+  ...args: ClientRequestArgs
+): NormalizedClientRequestArgs {
+  let url: URL
+  let options: ResolvedRequestOptions
+  let callback: HttpRequestCallback | undefined
+
+  log('arguments', args)
+  log('using default protocol:', defaultProtocol)
+
+  // Convert a url string into a URL instance
+  // and derive request options from it.
+  if (typeof args[0] === 'string') {
+    log('first argument is a location string:', args[0])
+
+    url = new URL(args[0])
+    log('created a url:', url)
+
+    const requestOptionsFromUrl = getRequestOptionsByUrl(url)
+    log('request options from url:', requestOptionsFromUrl)
+
+    options = resolveRequestOptions(args, url)
+    log('resolved request options:', options)
+
+    callback = resolveCallback(args)
+  }
+  // Handle a given URL instance as-is
+  // and derive request options from it.
+  else if (args[0] instanceof URL) {
+    url = args[0]
+    log('first argument is a URL:', url)
+
+    options = resolveRequestOptions(args, url)
+    log('derived request options:', options)
+
+    callback = resolveCallback(args)
+  }
+  // Handle a legacy URL instance and re-normalize from either a RequestOptions object
+  // or a WHATWG URL.
+  else if ('hash' in args[0] && !('method' in args[0])) {
+    const [legacyUrl] = args
+    log('first argument is a legacy URL:', legacyUrl)
+
+    if (legacyUrl.hostname === null) {
+      /**
+       * We are dealing with a relative url, so use the path as an "option" and
+       * merge in any existing options, giving priority to exising options -- i.e. a path in any
+       * existing options will take precedence over the one contained in the url. This is consistent
+       * with the behaviour in ClientRequest.
+       * @see https://github.com/nodejs/node/blob/d84f1312915fe45fe0febe888db692c74894c382/lib/_http_client.js#L122
+       */
+      log('given legacy URL is relative (no hostname)')
+
+      return isObject(args[1])
+        ? normalizeClientRequestArgs(
+            defaultProtocol,
+            { path: legacyUrl.path, ...args[1] },
+            args[2]
+          )
+        : normalizeClientRequestArgs(
+            defaultProtocol,
+            { path: legacyUrl.path },
+            args[1] as HttpRequestCallback
+          )
+    }
+
+    log('given legacy url is absolute')
+
+    // We are dealing with an absolute URL, so convert to WHATWG and try again.
+    const resolvedUrl = new URL(legacyUrl.href)
+
+    return args[1] === undefined
+      ? normalizeClientRequestArgs(defaultProtocol, resolvedUrl)
+      : typeof args[1] === 'function'
+      ? normalizeClientRequestArgs(defaultProtocol, resolvedUrl, args[1])
+      : normalizeClientRequestArgs(
+          defaultProtocol,
+          resolvedUrl,
+          args[1],
+          args[2]
+        )
+  }
+  // Handle a given "RequestOptions" object as-is
+  // and derive the URL instance from it.
+  else if (isObject(args[0])) {
+    options = args[0]
+    log('first argument is RequestOptions:', options)
+
+    // When handling a "RequestOptions" object without an explicit "protocol",
+    // infer the protocol from the request issuing module (http/https).
+    options.protocol = options.protocol || defaultProtocol
+    log('normalized request options:', options)
+
+    url = getUrlByRequestOptions(options)
+    log('created a URL from RequestOptions:', url.href)
+
+    callback = resolveCallback(args)
+  } else {
+    throw new Error(
+      `Failed to construct ClientRequest with these parameters: ${args}`
+    )
+  }
+
+  options.protocol = options.protocol || url.protocol
+  options.method = options.method || 'GET'
+
+  /**
+   * Infer a fallback agent from the URL protocol.
+   * The interception is done on the "ClientRequest" level ("NodeClientRequest")
+   * and it may miss the correct agent. Always align the agent
+   * with the URL protocol, if not provided.
+   *
+   * @note Respect the "agent: false" value.
+   */
+  if (typeof options.agent === 'undefined') {
+    const agent =
+      options.protocol === 'https:'
+        ? new HttpsAgent({
+            rejectUnauthorized: options.rejectUnauthorized,
+          })
+        : new HttpAgent()
+
+    options.agent = agent
+    log('resolved fallback agent:', agent)
+  }
+
+  log('successfully resolved url:', url.href)
+  log('successfully resolved options:', options)
+
+  return [url, options, callback]
+}

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

@@ -0,0 +1,40 @@
+import { normalizeClientRequestEndArgs } from './normalizeClientRequestEndArgs'
+
+test('returns [null, null, cb] given only the callback', () => {
+  const callback = () => {}
+  expect(normalizeClientRequestEndArgs(callback)).toEqual([
+    null,
+    null,
+    callback,
+  ])
+})
+
+test('returns [chunk, null, null] given only the chunk', () => {
+  expect(normalizeClientRequestEndArgs('chunk')).toEqual(['chunk', null, null])
+})
+
+test('returns [chunk, cb] given the chunk and the callback', () => {
+  const callback = () => {}
+  expect(normalizeClientRequestEndArgs('chunk', callback)).toEqual([
+    'chunk',
+    null,
+    callback,
+  ])
+})
+
+test('returns [chunk, encoding] given the chunk with the encoding', () => {
+  expect(normalizeClientRequestEndArgs('chunk', 'utf8')).toEqual([
+    'chunk',
+    'utf8',
+    null,
+  ])
+})
+
+test('returns [chunk, encoding, cb] given all three arguments', () => {
+  const callback = () => {}
+  expect(normalizeClientRequestEndArgs('chunk', 'utf8', callback)).toEqual([
+    'chunk',
+    'utf8',
+    callback,
+  ])
+})

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

@@ -0,0 +1,51 @@
+const debug = require('debug')('http normalizeClientRequestEndArgs')
+
+export type ClientRequestEndChunk = string | Buffer
+type ClientRequestEndCallback = () => void
+
+type HttpRequestEndArgs =
+  | []
+  | [ClientRequestEndCallback]
+  | [ClientRequestEndChunk, ClientRequestEndCallback?]
+  | [ClientRequestEndChunk, BufferEncoding, ClientRequestEndCallback?]
+
+type NormalizedHttpRequestEndParams = [
+  ClientRequestEndChunk | null,
+  BufferEncoding | null,
+  ClientRequestEndCallback | null
+]
+
+/**
+ * Normalizes a list of arguments given to the `ClientRequest.end()`
+ * method to always include `chunk`, `encoding`, and `callback`.
+ */
+export function normalizeClientRequestEndArgs(
+  ...args: HttpRequestEndArgs
+): NormalizedHttpRequestEndParams {
+  debug('arguments', args)
+  const normalizedArgs = new Array(3)
+    .fill(null)
+    .map((value, index) => args[index] || value)
+
+  normalizedArgs.sort((a, b) => {
+    // If first element is a function, move it rightwards.
+    if (typeof a === 'function') {
+      return 1
+    }
+
+    // If second element is a function, move the first leftwards.
+    if (typeof b === 'function') {
+      return -1
+    }
+
+    // If both elements are strings, preserve their original index.
+    if (typeof a === 'string' && typeof b === 'string') {
+      return normalizedArgs.indexOf(a) - normalizedArgs.indexOf(b)
+    }
+
+    return 0
+  })
+
+  debug('normalized args', normalizedArgs)
+  return normalizedArgs as NormalizedHttpRequestEndParams
+}

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

@@ -0,0 +1,35 @@
+import { normalizeClientRequestWriteArgs } from './normalizeClientRequestWriteArgs'
+
+test('returns a triplet of null given no chunk, encoding, or callback', () => {
+  expect(
+    normalizeClientRequestWriteArgs([
+      // @ts-ignore
+      undefined,
+      undefined,
+      undefined,
+    ])
+  ).toEqual([undefined, undefined, undefined])
+})
+
+test('returns [chunk, null, null] given only a chunk', () => {
+  expect(normalizeClientRequestWriteArgs(['chunk', undefined])).toEqual([
+    'chunk',
+    undefined,
+    undefined,
+  ])
+})
+
+test('returns [chunk, encoding] given only chunk and encoding', () => {
+  expect(normalizeClientRequestWriteArgs(['chunk', 'utf8'])).toEqual([
+    'chunk',
+    'utf8',
+    undefined,
+  ])
+})
+
+test('returns [chunk, encoding, cb] given all three arguments', () => {
+  const callbackFn = () => {}
+  expect(
+    normalizeClientRequestWriteArgs(['chunk', 'utf8', callbackFn])
+  ).toEqual(['chunk', 'utf8', callbackFn])
+})