@mswjs/interceptors 0.41.9 → 0.42.1

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

@@ -1,268 +0,0 @@
-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]
-}

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

@@ -1,48 +0,0 @@
-import type { Socket } from 'node:net'
-import { HTTPParser } from '_http_common'
-
-/**
- * @see https://github.com/nodejs/node/blob/f3adc11e37b8bfaaa026ea85c1cf22e3a0e29ae9/lib/_http_common.js#L180
- */
-export function freeParser(parser: HTTPParser<any>, socket?: Socket): void {
-  if (parser._consumed) {
-    parser.unconsume()
-  }
-
-  parser._headers = []
-  parser._url = ''
-  parser.socket = null
-  parser.incoming = null
-  parser.outgoing = null
-  parser.maxHeaderPairs = 2000
-  parser._consumed = false
-  parser.onIncoming = null
-
-  parser[HTTPParser.kOnHeaders] = null
-  parser[HTTPParser.kOnHeadersComplete] = null
-  parser[HTTPParser.kOnMessageBegin] = null
-  parser[HTTPParser.kOnMessageComplete] = null
-  parser[HTTPParser.kOnBody] = null
-  parser[HTTPParser.kOnExecute] = null
-  parser[HTTPParser.kOnTimeout] = null
-
-  parser.remove()
-  parser.free()
-
-  if (socket) {
-    /**
-     * @note Unassigning the socket's parser will fail this assertion
-     * if there's still some data being processed on the socket:
-     * @see https://github.com/nodejs/node/blob/4e1f39b678b37017ac9baa0971e3aeecd3b67b51/lib/_http_client.js#L613
-     */
-    if (socket.destroyed) {
-      // @ts-expect-error Node.js internals.
-      socket.parser = null
-    } else {
-      socket.once('end', () => {
-        // @ts-expect-error Node.js internals.
-        socket.parser = null
-      })
-    }
-  }
-}

package/src/interceptors/Socket/MockSocket.test.ts

@@ -1,264 +0,0 @@
-/**
- * @vitest-environment node
- */
-import { Socket } from 'node:net'
-import { vi, it, expect } from 'vitest'
-import { MockSocket } from './MockSocket'
-
-it(`keeps the socket connecting until it's destroyed`, () => {
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: vi.fn(),
-  })
-
-  expect(socket.connecting).toBe(true)
-
-  socket.destroy()
-  expect(socket.connecting).toBe(false)
-})
-
-it('calls the "write" on "socket.write()"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.write()
-  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
-})
-
-it('calls the "write" on "socket.write(chunk)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.write('hello')
-  expect(writeCallback).toHaveBeenCalledWith('hello', undefined, undefined)
-})
-
-it('calls the "write" on "socket.write(chunk, encoding)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.write('hello', 'utf8')
-  expect(writeCallback).toHaveBeenCalledWith('hello', 'utf8', undefined)
-})
-
-it('calls the "write" on "socket.write(chunk, encoding, callback)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  const callback = vi.fn()
-  socket.write('hello', 'utf8', callback)
-  expect(writeCallback).toHaveBeenCalledWith('hello', 'utf8', callback)
-})
-
-it('calls the "write" on "socket.end()"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.end()
-  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
-})
-
-it('calls the "write" on "socket.end(chunk)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.end('final')
-  expect(writeCallback).toHaveBeenCalledWith('final', undefined, undefined)
-})
-
-it('calls the "write" on "socket.end(chunk, encoding)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.end('final', 'utf8')
-  expect(writeCallback).toHaveBeenCalledWith('final', 'utf8', undefined)
-})
-
-it('calls the "write" on "socket.end(chunk, encoding, callback)"', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  const callback = vi.fn()
-  socket.end('final', 'utf8', callback)
-  expect(writeCallback).toHaveBeenCalledWith('final', 'utf8', callback)
-})
-
-it('calls the "write" on "socket.end()" without any arguments', () => {
-  const writeCallback = vi.fn()
-  const socket = new MockSocket({
-    write: writeCallback,
-    read: vi.fn(),
-  })
-
-  socket.end()
-  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
-})
-
-it('emits "finished" on .end() without any arguments', async () => {
-  const finishListener = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: vi.fn(),
-  })
-  socket.on('finish', finishListener)
-  socket.end()
-
-  await vi.waitFor(() => {
-    expect(finishListener).toHaveBeenCalledTimes(1)
-  })
-})
-
-it('calls the "read" on "socket.read(chunk)"', () => {
-  const readCallback = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: readCallback,
-  })
-
-  socket.push('hello')
-  expect(readCallback).toHaveBeenCalledWith('hello', undefined)
-})
-
-it('calls the "read" on "socket.read(chunk, encoding)"', () => {
-  const readCallback = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: readCallback,
-  })
-
-  socket.push('world', 'utf8')
-  expect(readCallback).toHaveBeenCalledWith('world', 'utf8')
-})
-
-it('calls the "read" on "socket.read(null)"', () => {
-  const readCallback = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: readCallback,
-  })
-
-  socket.push(null)
-  expect(readCallback).toHaveBeenCalledWith(null, undefined)
-})
-
-it('updates the writable state on "socket.end()"', async () => {
-  const finishListener = vi.fn()
-  const endListener = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: vi.fn(),
-  })
-  socket.on('finish', finishListener)
-  socket.on('end', endListener)
-
-  expect(socket.writable).toBe(true)
-  expect(socket.writableEnded).toBe(false)
-  expect(socket.writableFinished).toBe(false)
-
-  socket.write('hello')
-  // Finish the writable stream.
-  socket.end()
-
-  expect(socket.writable).toBe(false)
-  expect(socket.writableEnded).toBe(true)
-
-  // The "finish" event is emitted when writable is done.
-  // I.e. "socket.end()" is called.
-  await vi.waitFor(() => {
-    expect(finishListener).toHaveBeenCalledTimes(1)
-  })
-  expect(socket.writableFinished).toBe(true)
-})
-
-it('updates the readable state on "socket.push(null)"', async () => {
-  const endListener = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: vi.fn(),
-  })
-  socket.on('end', endListener)
-
-  expect(socket.readable).toBe(true)
-  expect(socket.readableEnded).toBe(false)
-
-  socket.push('hello')
-  socket.push(null)
-
-  expect(socket.readable).toBe(true)
-  expect(socket.readableEnded).toBe(false)
-
-  // Read the data to free the buffer and
-  // make Socket emit "end".
-  socket.read()
-
-  await vi.waitFor(() => {
-    expect(endListener).toHaveBeenCalledTimes(1)
-  })
-  expect(socket.readable).toBe(false)
-  expect(socket.readableEnded).toBe(true)
-})
-
-it('updates the readable/writable state on "socket.destroy()"', async () => {
-  const finishListener = vi.fn()
-  const endListener = vi.fn()
-  const closeListener = vi.fn()
-  const socket = new MockSocket({
-    write: vi.fn(),
-    read: vi.fn(),
-  })
-  socket.on('finish', finishListener)
-  socket.on('end', endListener)
-  socket.on('close', closeListener)
-
-  expect(socket.writable).toBe(true)
-  expect(socket.writableEnded).toBe(false)
-  expect(socket.writableFinished).toBe(false)
-  expect(socket.readable).toBe(true)
-
-  socket.destroy()
-
-  expect(socket.writable).toBe(false)
-  // The ".end()" wasn't called.
-  expect(socket.writableEnded).toBe(false)
-  expect(socket.writableFinished).toBe(false)
-  expect(socket.readable).toBe(false)
-
-  await vi.waitFor(() => {
-    expect(closeListener).toHaveBeenCalledTimes(1)
-  })
-
-  // Neither "finish" nor "end" events are emitted
-  // when you destroy the stream. If you want those,
-  // call ".end()", then destroy the stream.
-  expect(finishListener).not.toHaveBeenCalled()
-  expect(endListener).not.toHaveBeenCalled()
-  expect(socket.writableFinished).toBe(false)
-
-  // The "end" event was never emitted so "readableEnded"
-  // remains false.
-  expect(socket.readableEnded).toBe(false)
-})

package/src/interceptors/Socket/MockSocket.ts

@@ -1,58 +0,0 @@
-import net from 'node:net'
-import {
-  normalizeSocketWriteArgs,
-  type WriteArgs,
-  type WriteCallback,
-} from './utils/normalizeSocketWriteArgs'
-
-export interface MockSocketOptions {
-  write: (
-    chunk: Buffer | string,
-    encoding: BufferEncoding | undefined,
-    callback?: WriteCallback
-  ) => void
-
-  read: (chunk: Buffer, encoding: BufferEncoding | undefined) => void
-}
-
-export class MockSocket extends net.Socket {
-  public connecting: boolean
-
-  constructor(protected readonly options: MockSocketOptions) {
-    super()
-    this.connecting = false
-    this.connect()
-
-    this._final = (callback) => {
-      callback(null)
-    }
-  }
-
-  public connect() {
-    // The connection will remain pending until
-    // the consumer decides to handle it.
-    this.connecting = true
-    return this
-  }
-
-  public write(...args: Array<unknown>): boolean {
-    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
-      args as WriteArgs
-    )
-    this.options.write(chunk, encoding, callback)
-    return true
-  }
-
-  public end(...args: Array<unknown>) {
-    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
-      args as WriteArgs
-    )
-    this.options.write(chunk, encoding, callback)
-    return super.end.apply(this, args as any)
-  }
-
-  public push(chunk: any, encoding?: BufferEncoding): boolean {
-    this.options.read(chunk, encoding)
-    return super.push(chunk, encoding)
-  }
-}

package/src/interceptors/Socket/utils/baseUrlFromConnectionOptions.ts

@@ -1,26 +0,0 @@
-export function baseUrlFromConnectionOptions(options: any): URL {
-  if ('href' in options) {
-    return new URL(options.href)
-  }
-
-  const protocol = options.port === 443 ? 'https:' : 'http:'
-  const host = options.host
-
-  const url = new URL(`${protocol}//${host}`)
-
-  if (options.port) {
-    url.port = options.port.toString()
-  }
-
-  if (options.path) {
-    url.pathname = options.path
-  }
-
-  if (options.auth) {
-    const [username, password] = options.auth.split(':')
-    url.username = username
-    url.password = password
-  }
-
-  return url
-}