@mswjs/interceptors 0.31.1 → 0.32.1

package/src/interceptors/ClientRequest/http.request.ts

@@ -1,27 +0,0 @@
-import { ClientRequest } from 'http'
-import { Logger } from '@open-draft/logger'
-import {
-  NodeClientOptions,
-  NodeClientRequest,
-  Protocol,
-} from './NodeClientRequest'
-import {
-  normalizeClientRequestArgs,
-  ClientRequestArgs,
-} from './utils/normalizeClientRequestArgs'
-
-const logger = new Logger('http request')
-
-export function request(protocol: Protocol, options: NodeClientOptions) {
-  return function interceptorsHttpRequest(
-    ...args: ClientRequestArgs
-  ): ClientRequest {
-    logger.info('request call (protocol "%s"):', protocol, args)
-
-    const clientRequestArgs = normalizeClientRequestArgs(
-      `${protocol}:`,
-      ...args
-    )
-    return new NodeClientRequest(clientRequestArgs, options)
-  }
-}

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

@@ -1,26 +0,0 @@
-import { it, expect } from 'vitest'
-import { Socket } from 'net'
-import { IncomingMessage } from 'http'
-import { Stream, Readable, EventEmitter } from 'stream'
-import { cloneIncomingMessage, IS_CLONE } from './cloneIncomingMessage'
-
-it('clones a given IncomingMessage', () => {
-  const message = new IncomingMessage(new Socket())
-  message.statusCode = 200
-  message.statusMessage = 'OK'
-  message.headers = { 'x-powered-by': 'msw' }
-  const clone = cloneIncomingMessage(message)
-
-  // Prototypes must be preserved.
-  expect(clone).toBeInstanceOf(IncomingMessage)
-  expect(clone).toBeInstanceOf(EventEmitter)
-  expect(clone).toBeInstanceOf(Stream)
-  expect(clone).toBeInstanceOf(Readable)
-
-  expect(clone.statusCode).toEqual(200)
-  expect(clone.statusMessage).toEqual('OK')
-  expect(clone.headers).toHaveProperty('x-powered-by', 'msw')
-
-  // Cloned IncomingMessage must be marked respectively.
-  expect(clone[IS_CLONE]).toEqual(true)
-})

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

@@ -1,74 +0,0 @@
-import { IncomingMessage } from 'http'
-import { PassThrough } from 'stream'
-
-export const IS_CLONE = Symbol('isClone')
-
-export interface ClonedIncomingMessage extends IncomingMessage {
-  [IS_CLONE]: boolean
-}
-
-/**
- * Clones a given `http.IncomingMessage` instance.
- */
-export function cloneIncomingMessage(
-  message: IncomingMessage
-): ClonedIncomingMessage {
-  const clone = message.pipe(new PassThrough())
-
-  // Inherit all direct "IncomingMessage" properties.
-  inheritProperties(message, clone)
-
-  // Deeply inherit the message prototypes (Readable, Stream, EventEmitter, etc.).
-  const clonedPrototype = Object.create(IncomingMessage.prototype)
-  getPrototypes(clone).forEach((prototype) => {
-    inheritProperties(prototype, clonedPrototype)
-  })
-  Object.setPrototypeOf(clone, clonedPrototype)
-
-  Object.defineProperty(clone, IS_CLONE, {
-    enumerable: true,
-    value: true,
-  })
-
-  return clone as unknown as ClonedIncomingMessage
-}
-
-/**
- * Returns a list of all prototypes the given object extends.
- */
-function getPrototypes(source: object): object[] {
-  const prototypes: object[] = []
-  let current = source
-
-  while ((current = Object.getPrototypeOf(current))) {
-    prototypes.push(current)
-  }
-
-  return prototypes
-}
-
-/**
- * Inherits a given target object properties and symbols
- * onto the given source object.
- * @param source Object which should acquire properties.
- * @param target Object to inherit the properties from.
- */
-function inheritProperties(source: object, target: object): void {
-  const properties = [
-    ...Object.getOwnPropertyNames(source),
-    ...Object.getOwnPropertySymbols(source),
-  ]
-
-  for (const property of properties) {
-    if (target.hasOwnProperty(property)) {
-      continue
-    }
-
-    const descriptor = Object.getOwnPropertyDescriptor(source, property)
-    if (!descriptor) {
-      continue
-    }
-
-    Object.defineProperty(target, property, descriptor)
-  }
-}

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

@@ -1,144 +0,0 @@
-import { it, expect } from 'vitest'
-import { Logger } from '@open-draft/logger'
-import { HttpRequestEventMap } from '../../..'
-import { NodeClientRequest } from '../NodeClientRequest'
-import { createRequest } from './createRequest'
-import { Emitter } from 'strict-event-emitter'
-
-const emitter = new Emitter<HttpRequestEventMap>()
-const logger = new Logger('test')
-
-it('creates a fetch Request with a JSON body', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      },
-      () => {},
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-  clientRequest.write(JSON.stringify({ firstName: 'John' }))
-
-  const request = createRequest(clientRequest)
-
-  expect(request.method).toBe('POST')
-  expect(request.url).toBe('https://api.github.com/')
-  expect(request.headers.get('Content-Type')).toBe('application/json')
-  expect(await request.json()).toEqual({ firstName: 'John' })
-})
-
-it('creates a fetch Request with an empty body', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      {
-        method: 'GET',
-        headers: {
-          Accept: 'application/json',
-        },
-      },
-      () => {},
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-
-  const request = createRequest(clientRequest)
-
-  expect(request.method).toBe('GET')
-  expect(request.url).toBe('https://api.github.com/')
-  expect(request.headers.get('Accept')).toBe('application/json')
-  expect(request.body).toBe(null)
-})
-
-it('creates a fetch Request with an empty string body', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      {
-        method: 'HEAD',
-      },
-      () => {},
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-  clientRequest.write('')
-
-  const request = createRequest(clientRequest)
-
-  expect(request.method).toBe('HEAD')
-  expect(request.url).toBe('https://api.github.com/')
-  expect(request.body).toBe(null)
-})
-
-it('creates a fetch Request with an empty password', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      { auth: 'username:' },
-      () => {},
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-  clientRequest.write('')
-
-  const request = createRequest(clientRequest)
-
-  expect(request.headers.get('Authorization')).toBe(`Basic ${btoa('username:')}`)
-  expect(request.url).toBe('https://api.github.com/')
-})
-
-it('creates a fetch Request with an empty username', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      { auth: ':password' },
-      () => {},
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-  clientRequest.write('')
-
-  const request = createRequest(clientRequest)
-
-  expect(request.headers.get('Authorization')).toBe(`Basic ${btoa(':password')}`)
-  expect(request.url).toBe('https://api.github.com/')
-})
-
-it('creates a fetch Request with falsy headers', async () => {
-  const clientRequest = new NodeClientRequest(
-    [
-      new URL('https://api.github.com'),
-      { headers: { 'foo': 0, 'empty': '' }}
-    ],
-    {
-      emitter,
-      logger,
-    }
-  )
-  clientRequest.write('')
-
-  const request = createRequest(clientRequest)
-
-  expect(request.headers.get('foo')).toBe('0')
-  expect(request.headers.get('empty')).toBe('')
-})

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

@@ -1,51 +0,0 @@
-import type { NodeClientRequest } from '../NodeClientRequest'
-
-/**
- * Creates a Fetch API `Request` instance from the given `http.ClientRequest`.
- */
-export function createRequest(clientRequest: NodeClientRequest): Request {
-  const headers = new Headers()
-
-  const outgoingHeaders = clientRequest.getHeaders()
-  for (const headerName in outgoingHeaders) {
-    const headerValue = outgoingHeaders[headerName]
-
-    if (typeof headerValue === 'undefined') {
-      continue
-    }
-
-    const valuesList = Array.prototype.concat([], headerValue)
-    for (const value of valuesList) {
-      headers.append(headerName, value.toString())
-    }
-  }
-
-  /**
-   * Translate the authentication from the request URL to
-   * the request "Authorization" header.
-   * @see https://github.com/mswjs/interceptors/issues/438
-   */
-  if (clientRequest.url.username || clientRequest.url.password) {
-    const username = decodeURIComponent(clientRequest.url.username || '')
-    const password = decodeURIComponent(clientRequest.url.password || '')
-    const auth = `${username}:${password}`
-    headers.set('Authorization', `Basic ${btoa(auth)}`)
-
-    // Remove the credentials from the URL since you cannot
-    // construct a Request instance with such a URL.
-    clientRequest.url.username = ''
-    clientRequest.url.password = ''
-  }
-
-  const method = clientRequest.method || 'GET'
-
-  return new Request(clientRequest.url, {
-    method,
-    headers,
-    credentials: 'same-origin',
-    body:
-      method === 'HEAD' || method === 'GET'
-        ? null
-        : clientRequest.requestBuffer,
-  })
-}

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

@@ -1,53 +0,0 @@
-import { it, expect } from 'vitest'
-import { Socket } from 'net'
-import * as http from 'http'
-import { createResponse } from './createResponse'
-import { RESPONSE_STATUS_CODES_WITHOUT_BODY } from '../../../utils/responseUtils'
-
-it('creates a fetch api response from http incoming message', async () => {
-  const message = new http.IncomingMessage(new Socket())
-  message.statusCode = 201
-  message.statusMessage = 'Created'
-  message.headers['content-type'] = 'application/json'
-
-  const response = createResponse(message)
-
-  message.emit('data', Buffer.from('{"firstName":'))
-  message.emit('data', Buffer.from('"John"}'))
-  message.emit('end')
-
-  expect(response.status).toBe(201)
-  expect(response.statusText).toBe('Created')
-  expect(response.headers.get('content-type')).toBe('application/json')
-  expect(await response.json()).toEqual({ firstName: 'John' })
-})
-
-/**
- * @note Ignore 1xx response status code because those cannot
- * be used as the init to the "Response" constructor.
- */
-const CONSTRUCTABLE_RESPONSE_STATUS_CODES = Array.from(
-  RESPONSE_STATUS_CODES_WITHOUT_BODY
-).filter((status) => status >= 200)
-
-it.each(CONSTRUCTABLE_RESPONSE_STATUS_CODES)(
-  'ignores message body for %i response status',
-  (responseStatus) => {
-    const message = new http.IncomingMessage(new Socket())
-    message.statusCode = responseStatus
-
-    const response = createResponse(message)
-
-    // These chunks will be ignored: this response
-    // cannot have body. We don't forward this error to
-    // the consumer because it's us who converts the
-    // internal stream to a Fetch API Response instance.
-    // Consumers will rely on the Response API when constructing
-    // mocked responses.
-    message.emit('data', Buffer.from('hello'))
-    message.emit('end')
-
-    expect(response.status).toBe(responseStatus)
-    expect(response.body).toBe(null)
-  }
-)

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

@@ -1,55 +0,0 @@
-import type { IncomingHttpHeaders, IncomingMessage } from 'http'
-import { isResponseWithoutBody } from '../../../utils/responseUtils'
-
-/**
- * Creates a Fetch API `Response` instance from the given
- * `http.IncomingMessage` instance.
- */
-export function createResponse(message: IncomingMessage): Response {
-  const responseBodyOrNull = isResponseWithoutBody(message.statusCode || 200)
-    ? null
-    : new ReadableStream({
-        start(controller) {
-          message.on('data', (chunk) => controller.enqueue(chunk))
-          message.on('end', () => controller.close())
-
-          /**
-           * @todo Should also listen to the "error" on the message
-           * and forward it to the controller. Otherwise the stream
-           * will pend indefinitely.
-           */
-        },
-      })
-
-  return new Response(responseBodyOrNull, {
-    status: message.statusCode,
-    statusText: message.statusMessage,
-    headers: createHeadersFromIncomingHttpHeaders(message.headers),
-  })
-}
-
-function createHeadersFromIncomingHttpHeaders(
-  httpHeaders: IncomingHttpHeaders
-): Headers {
-  const headers = new Headers()
-
-  for (const headerName in httpHeaders) {
-    const headerValues = httpHeaders[headerName]
-
-    if (typeof headerValues === 'undefined') {
-      continue
-    }
-
-    if (Array.isArray(headerValues)) {
-      headerValues.forEach((headerValue) => {
-        headers.append(headerName, headerValue)
-      })
-
-      continue
-    }
-
-    headers.set(headerName, headerValues)
-  }
-
-  return headers
-}

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

@@ -1,41 +0,0 @@
-import { it, expect } from 'vitest'
-import { normalizeClientRequestEndArgs } from './normalizeClientRequestEndArgs'
-
-it('returns [null, null, cb] given only the callback', () => {
-  const callback = () => {}
-  expect(normalizeClientRequestEndArgs(callback)).toEqual([
-    null,
-    null,
-    callback,
-  ])
-})
-
-it('returns [chunk, null, null] given only the chunk', () => {
-  expect(normalizeClientRequestEndArgs('chunk')).toEqual(['chunk', null, null])
-})
-
-it('returns [chunk, cb] given the chunk and the callback', () => {
-  const callback = () => {}
-  expect(normalizeClientRequestEndArgs('chunk', callback)).toEqual([
-    'chunk',
-    null,
-    callback,
-  ])
-})
-
-it('returns [chunk, encoding] given the chunk with the encoding', () => {
-  expect(normalizeClientRequestEndArgs('chunk', 'utf8')).toEqual([
-    'chunk',
-    'utf8',
-    null,
-  ])
-})
-
-it('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

@@ -1,53 +0,0 @@
-import { Logger } from '@open-draft/logger'
-
-const logger = new Logger('utils getUrlByRequestOptions')
-
-export type ClientRequestEndChunk = string | Buffer
-export 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 {
-  logger.info('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
-  })
-
-  logger.info('normalized args', normalizedArgs)
-  return normalizedArgs as NormalizedHttpRequestEndParams
-}

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

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

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

@@ -1,39 +0,0 @@
-import { Logger } from '@open-draft/logger'
-
-const logger = new Logger('http normalizeWriteArgs')
-
-export type ClientRequestWriteCallback = (error?: Error | null) => void
-export type ClientRequestWriteArgs = [
-  chunk: string | Buffer,
-  encoding?: BufferEncoding | ClientRequestWriteCallback,
-  callback?: ClientRequestWriteCallback
-]
-
-export type NormalizedClientRequestWriteArgs = [
-  chunk: string | Buffer,
-  encoding?: BufferEncoding,
-  callback?: ClientRequestWriteCallback
-]
-
-export function normalizeClientRequestWriteArgs(
-  args: ClientRequestWriteArgs
-): NormalizedClientRequestWriteArgs {
-  logger.info('normalizing ClientRequest.write arguments...', args)
-
-  const chunk = args[0]
-  const encoding =
-    typeof args[1] === 'string' ? (args[1] as BufferEncoding) : undefined
-  const callback = typeof args[1] === 'function' ? args[1] : args[2]
-
-  const writeArgs: NormalizedClientRequestWriteArgs = [
-    chunk,
-    encoding,
-    callback,
-  ]
-  logger.info(
-    'successfully normalized ClientRequest.write arguments:',
-    writeArgs
-  )
-
-  return writeArgs
-}