@depup/mswjs__interceptors 0.41.3-depup.0

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

@@ -0,0 +1,427 @@
+import { it, expect } from 'vitest'
+import { parse } from 'url'
+import { globalAgent as httpGlobalAgent, RequestOptions } from 'http'
+import { Agent as HttpsAgent, globalAgent as httpsGlobalAgent } from 'https'
+import { getUrlByRequestOptions } from '../../../utils/getUrlByRequestOptions'
+import { normalizeClientRequestArgs } from './normalizeClientRequestArgs'
+
+it('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')
+})
+
+it('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')
+})
+
+it('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')
+})
+
+it('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')
+})
+
+it('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')
+})
+
+it('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')
+})
+
+it('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).toBeTypeOf('function')
+  expect(callback?.name).toEqual('cb')
+})
+
+it('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()
+})
+
+it('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.
+  // `urlToHttpOptions` from `node:url` generates additional
+  // ClientRequest options, some of which are not legally allowed.
+  expect(options).toMatchObject<RequestOptions>({
+    agent: false,
+    _defaultAgent: httpsGlobalAgent,
+    protocol: url.protocol,
+    method: 'GET',
+    headers: {
+      'Content-Type': 'text/plain',
+    },
+    hostname: url.hostname,
+    path: url.pathname,
+  })
+
+  // Callback must be preserved.
+  expect(callback).toBeTypeOf('function')
+  expect(callback?.name).toEqual('cb')
+})
+
+it('handles [URL, RequestOptions] where options have custom "hostname"', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com/path-from-url'),
+    {
+      hostname: 'host-from-options.com',
+    },
+  ])
+  expect(url.href).toBe('http://host-from-options.com/path-from-url')
+  expect(options).toMatchObject({
+    hostname: 'host-from-options.com',
+    path: '/path-from-url',
+  })
+})
+
+it('handles [URL, RequestOptions] where options contain "host" and "path" and "port"', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com/path-from-url?a=b&c=d'),
+    {
+      hostname: 'host-from-options.com',
+      path: '/path-from-options',
+      port: 1234,
+    },
+  ])
+  // Must remove the query string since it's not specified in "options.path"
+  expect(url.href).toBe('http://host-from-options.com:1234/path-from-options')
+  expect(options).toMatchObject<RequestOptions>({
+    hostname: 'host-from-options.com',
+    path: '/path-from-options',
+    port: 1234,
+  })
+})
+
+it('handles [URL, RequestOptions] where options contain "path" with query string', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com/path-from-url?a=b&c=d'),
+    {
+      path: '/path-from-options?foo=bar&baz=xyz',
+    },
+  ])
+  expect(url.href).toBe('http://example.com/path-from-options?foo=bar&baz=xyz')
+  expect(options).toMatchObject<RequestOptions>({
+    hostname: 'example.com',
+    path: '/path-from-options?foo=bar&baz=xyz',
+  })
+})
+
+it('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).toMatchObject(initialOptions)
+
+  // Callback must be preserved.
+  expect(callback).toBeTypeOf('function')
+  expect(callback?.name).toEqual('cb')
+})
+
+it('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
+ */
+it('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).toMatchObject(initialOptions)
+
+  // Options protocol must be inferred from the request issuing module.
+  expect(options.protocol).toEqual('https:')
+
+  // Callback must be preserved.
+  expect(callback).toBeTypeOf('function')
+  expect(callback?.name).toEqual('cb')
+})
+
+it('sets the default Agent for HTTP request', () => {
+  const [, options] = normalizeClientRequestArgs('http:', [
+    'http://github.com',
+    {},
+  ])
+
+  expect(options._defaultAgent).toEqual(httpGlobalAgent)
+})
+
+it('sets the default Agent for HTTPS request', () => {
+  const [, options] = normalizeClientRequestArgs('https:', [
+    'https://github.com',
+    {},
+  ])
+
+  expect(options._defaultAgent).toEqual(httpsGlobalAgent)
+})
+
+it('preserves a custom default Agent when set', () => {
+  const [, options] = normalizeClientRequestArgs('https:', [
+    'https://github.com',
+    {
+      /**
+       * @note Intentionally incorrect Agent for HTTPS request.
+       */
+      _defaultAgent: httpGlobalAgent,
+    },
+  ])
+
+  expect(options._defaultAgent).toEqual(httpGlobalAgent)
+})
+
+it('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.hostname).toEqual(url.hostname)
+  expect(options.path).toEqual(url.pathname)
+})
+
+it('respects custom "options.path" over URL path', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com/path-from-url'),
+    {
+      path: '/path-from-options',
+    },
+  ])
+
+  expect(url.href).toBe('http://example.com/path-from-options')
+  expect(options.protocol).toBe('http:')
+  expect(options.hostname).toBe('example.com')
+  expect(options.path).toBe('/path-from-options')
+})
+
+it('respects custom "options.path" over URL path with query string', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com/path-from-url?a=b&c=d'),
+    {
+      path: '/path-from-options',
+    },
+  ])
+
+  // Must replace both the path and the query string.
+  expect(url.href).toBe('http://example.com/path-from-options')
+  expect(options.protocol).toBe('http:')
+  expect(options.hostname).toBe('example.com')
+  expect(options.path).toBe('/path-from-options')
+})
+
+it('preserves URL query string', () => {
+  const [url, options] = normalizeClientRequestArgs('http:', [
+    new URL('http://example.com:8080/resource?a=b&c=d'),
+  ])
+
+  expect(url.href).toBe('http://example.com:8080/resource?a=b&c=d')
+  expect(options.protocol).toBe('http:')
+  // expect(options.host).toBe('example.com:8080')
+  expect(options.hostname).toBe('example.com')
+  // Query string is a part of the options path.
+  expect(options.path).toBe('/resource?a=b&c=d')
+  expect(options.port).toBe(8080)
+})

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

@@ -0,0 +1,268 @@
+import { urlToHttpOptions } from 'node:url'
+import {
+  Agent as HttpAgent,
+  globalAgent as httpGlobalAgent,
+  IncomingMessage,
+} from 'node:http'
+import {
+  RequestOptions,
+  Agent as HttpsAgent,
+  globalAgent as httpsGlobalAgent,
+} from 'node:https'
+import {
+  /**
+   * @note Use the Node.js URL instead of the global URL
+   * because environments like JSDOM may override the global,
+   * breaking the compatibility with Node.js.
+   * @see https://github.com/node-fetch/node-fetch/issues/1376#issuecomment-966435555
+   */
+  URL,
+  Url as LegacyURL,
+  parse as parseUrl,
+} from 'node:url'
+import { Logger } from '@open-draft/logger'
+import {
+  ResolvedRequestOptions,
+  getUrlByRequestOptions,
+} from '../../../utils/getUrlByRequestOptions'
+import { cloneObject } from '../../../utils/cloneObject'
+import { isObject } from '../../../utils/isObject'
+
+const logger = new Logger('http normalizeClientRequestArgs')
+
+export type HttpRequestCallback = (response: IncomingMessage) => void
+
+export type ClientRequestArgs =
+  // Request without any arguments is also possible.
+  | []
+  | [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') {
+    logger.info('request options not provided, deriving from the url', url)
+    return urlToHttpOptions(url)
+  }
+
+  if (args[1]) {
+    logger.info('has custom RequestOptions!', args[1])
+    const requestOptionsFromUrl = urlToHttpOptions(url)
+
+    logger.info('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
+     */
+    logger.info('cloning RequestOptions...')
+    const clonedRequestOptions = cloneObject(args[1])
+    logger.info('successfully cloned RequestOptions!', clonedRequestOptions)
+
+    return {
+      ...requestOptionsFromUrl,
+      ...clonedRequestOptions,
+    }
+  }
+
+  logger.info('using an empty object as request options')
+  return {} as RequestOptions
+}
+
+/**
+ * Overrides the given `URL` instance with the explicit properties provided
+ * on the `RequestOptions` object. The options object takes precedence,
+ * and will replace URL properties like "host", "path", and "port", if specified.
+ */
+function overrideUrlByRequestOptions(url: URL, options: RequestOptions): URL {
+  url.host = options.host || url.host
+  url.hostname = options.hostname || url.hostname
+  url.port = options.port ? options.port.toString() : url.port
+
+  if (options.path) {
+    const parsedOptionsPath = parseUrl(options.path, false)
+    url.pathname = parsedOptionsPath.pathname || ''
+    url.search = parsedOptionsPath.search || ''
+  }
+
+  return url
+}
+
+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
+
+  logger.info('arguments', args)
+  logger.info('using default protocol:', defaultProtocol)
+
+  // Support "http.request()" calls without any arguments.
+  // That call results in a "GET http://localhost" request.
+  if (args.length === 0) {
+    const url = new URL('http://localhost')
+    const options = resolveRequestOptions(args, url)
+    return [url, options]
+  }
+
+  // Convert a url string into a URL instance
+  // and derive request options from it.
+  if (typeof args[0] === 'string') {
+    logger.info('first argument is a location string:', args[0])
+
+    url = new URL(args[0])
+    logger.info('created a url:', url)
+
+    const requestOptionsFromUrl = urlToHttpOptions(url)
+    logger.info('request options from url:', requestOptionsFromUrl)
+
+    options = resolveRequestOptions(args, url)
+    logger.info('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]
+    logger.info('first argument is a URL:', url)
+
+    // Check if the second provided argument is RequestOptions.
+    // If it is, check if "options.path" was set and rewrite it
+    // on the input URL.
+    // Do this before resolving options from the URL below
+    // to prevent query string from being duplicated in the path.
+    if (typeof args[1] !== 'undefined' && isObject<RequestOptions>(args[1])) {
+      url = overrideUrlByRequestOptions(url, args[1])
+    }
+
+    options = resolveRequestOptions(args, url)
+    logger.info('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
+    logger.info('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 existing 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
+       */
+      logger.info('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,
+          ])
+    }
+
+    logger.info('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] as any) }
+    logger.info('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
+    logger.info('normalized request options:', options)
+
+    url = getUrlByRequestOptions(options)
+    logger.info('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'
+
+  /**
+   * Ensure that the default Agent is always set.
+   * This prevents the protocol mismatch for requests with { agent: false },
+   * where the global Agent is inferred.
+   * @see https://github.com/mswjs/msw/issues/1150
+   * @see https://github.com/nodejs/node/blob/418ff70b810f0e7112d48baaa72932a56cfa213b/lib/_http_client.js#L130
+   * @see https://github.com/nodejs/node/blob/418ff70b810f0e7112d48baaa72932a56cfa213b/lib/_http_client.js#L157-L159
+   */
+  if (!options._defaultAgent) {
+    logger.info(
+      'has no default agent, setting the default agent for "%s"',
+      options.protocol
+    )
+
+    options._defaultAgent =
+      options.protocol === 'https:' ? httpsGlobalAgent : httpGlobalAgent
+  }
+
+  logger.info('successfully resolved url:', url.href)
+  logger.info('successfully resolved options:', options)
+  logger.info('successfully resolved callback:', callback)
+
+  /**
+   * @note If the user-provided URL is not a valid URL in Node.js,
+   * (e.g. the one provided by the JSDOM polyfills), case it to
+   * string. Otherwise, this throws on Node.js incompatibility
+   * (`ERR_INVALID_ARG_TYPE` on the connection listener)
+   * @see https://github.com/node-fetch/node-fetch/issues/1376#issuecomment-966435555
+   */
+  if (!(url instanceof URL)) {
+    url = (url as any).toString()
+  }
+
+  return [url, options, callback]
+}