nock 15.0.0 → 15.0.1

package/index.js

@@ -1,55 +0,0 @@
-'use strict'
-
-const back = require('./lib/back')
-const emitter = require('./lib/global_emitter')
-const {
-  activate,
-  isActive,
-  isDone,
-  isOn,
-  pendingMocks,
-  activeMocks,
-  removeInterceptor,
-  disableNetConnect,
-  enableNetConnect,
-  removeAll,
-  abortPendingRequests,
-} = require('./lib/intercept')
-const recorder = require('./lib/recorder')
-const { Scope, load, loadDefs, define } = require('./lib/scope')
-const { getDecompressedGetBody } = require('./lib/utils/node')
-
-module.exports = (basePath, options) => new Scope(basePath, options)
-
-Object.assign(module.exports, {
-  activate,
-  isActive,
-  isDone,
-  pendingMocks,
-  activeMocks,
-  removeInterceptor,
-  disableNetConnect,
-  enableNetConnect,
-  cleanAll: removeAll,
-  abortPendingRequests,
-  load,
-  loadDefs,
-  define,
-  emitter,
-  recorder: {
-    rec: recorder.record,
-    clear: recorder.clear,
-    play: recorder.outputs,
-  },
-  restore: recorder.restore,
-  back,
-  getDecompressedGetBody,
-})
-
-// We always activate Nock on import, overriding the globals.
-// Setting the Back mode "activates" Nock by overriding the global entries in the `http/s` modules.
-// If Nock Back is configured, we need to honor that setting for backward compatibility,
-// otherwise we rely on Nock Back's default initializing side effect.
-if (isOn()) {
-  back.setMode(process.env.NOCK_BACK_MODE || 'dryrun')
-}

package/lib/create_response.js

@@ -1,53 +0,0 @@
-'use strict'
-
-const { STATUS_CODES } = require('node:http')
-
-/**
- * Creates a Fetch API `Response` instance from the given
- * `http.IncomingMessage` instance.
- * Inspired by: https://github.com/mswjs/interceptors/blob/04152ed914f8041272b6e92ed374216b8177e1b2/src/interceptors/ClientRequest/utils/createResponse.ts#L8
- */
-
-/**
- * Response status codes for responses that cannot have body.
- * @see https://fetch.spec.whatwg.org/#statuses
- */
-const responseStatusCodesWithoutBody = [204, 205, 304]
-
-/**
- * @param {import('http').IncomingMessage} message
- * @param {AbortSignal} signal
- */
-function createResponse(message, signal) {
-  const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
-    message.statusCode || 200,
-  )
-    ? null
-    : new ReadableStream({
-        start(controller) {
-          message.on('data', chunk => controller.enqueue(chunk))
-          message.on('end', () => controller.close())
-          message.on('error', error => controller.error(error))
-          signal.addEventListener('abort', () => message.destroy(signal.reason))
-        },
-        cancel() {
-          message.destroy()
-        },
-      })
-
-  const rawHeaders = new Headers()
-  for (let i = 0; i < message.rawHeaders.length; i += 2) {
-    rawHeaders.append(message.rawHeaders[i], message.rawHeaders[i + 1])
-  }
-
-  // @mswjs/interceptors supports rawHeaders. https://github.com/mswjs/interceptors/pull/598
-  const response = new Response(responseBodyOrNull, {
-    status: message.statusCode,
-    statusText: message.statusMessage || STATUS_CODES[message.statusCode],
-    headers: rawHeaders,
-  })
-
-  return response
-}
-
-module.exports = { createResponse }

package/lib/debug.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { debuglog } = require('node:util')
-
-module.exports.back = debuglog('nock:back')
-module.exports.common = debuglog('nock:common')
-module.exports.intercept = debuglog('nock:intercept')
-module.exports.request_overrider = debuglog('nock:request_overrider')
-module.exports.playback_interceptor = debuglog('nock:playback_interceptor')
-module.exports.recorder = debuglog('nock:recorder')
-module.exports.socket = debuglog('nock:socket')
-module.exports.scopeDebuglog = namespace => debuglog(`nock:scope:${namespace}`)

package/lib/global_emitter.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const { EventEmitter } = require('node:events')
-
-module.exports = new EventEmitter()

package/lib/interceptors/builtin.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const http = require('node:http')
-const { getRawRequest, BatchInterceptor } = require('@mswjs/interceptors')
-const {
-  default: nodeInterceptors,
-} = require('@mswjs/interceptors/presets/node')
-const common = require('../common')
-const handleRequest = require('../handle-request')
-const { arrayBuffer } = require('node:stream/consumers')
-const { getClientRequestBodyStream } = require('@mswjs/interceptors/utils/node')
-const { setDecompressedGetBody } = require('../utils/node')
-
-const interceptor = new BatchInterceptor({
-  name: 'nock-interceptor',
-  interceptors: nodeInterceptors,
-})
-
-function activate() {
-  interceptor.apply()
-
-  // Force msw to forward Nock's error instead of coerce it into 500 error
-  interceptor.on('unhandledException', ({ controller, error }) => {
-    controller.errorWith(error)
-  })
-  interceptor.on('request', async function ({ request, controller }) {
-    if (request.headers.get('expect') === '100-continue') {
-      // We currently do not support mocking 100-continue responses, so they are passed through for now.
-      return
-    }
-    const rawRequest = getRawRequest(request)
-
-    // If this is GET request with body, we need to read the body from the socket because Fetch API doesn't support this.
-    const requestBodyBuffer = common.decompressRequestBody(
-      rawRequest instanceof http.ClientRequest &&
-        request.method === 'GET' &&
-        request.headers.get('content-length') > 0
-        ? await arrayBuffer(getClientRequestBodyStream(request))
-        : await request.clone().arrayBuffer(),
-      request.headers.get('content-encoding') || '',
-    )
-
-    const decompressedRequest = new Request(request, {
-      body:
-        requestBodyBuffer.length > 0 && request.method !== 'GET'
-          ? requestBodyBuffer
-          : undefined,
-    })
-    if (requestBodyBuffer.byteLength > 0 && request.method === 'GET') {
-      setDecompressedGetBody(decompressedRequest, requestBodyBuffer)
-    }
-
-    const response = await handleRequest(decompressedRequest)
-    if (response) {
-      controller.respondWith(response)
-    }
-  })
-}
-
-function deactivate() {
-  interceptor.dispose()
-}
-
-module.exports = {
-  activate,
-  deactivate,
-}

package/lib/interceptors/undici.js

@@ -1,78 +0,0 @@
-'use strict'
-
-// This file is loaded lazily after confirming undici is installed
-// eslint-disable-next-line n/no-unpublished-require
-const undici = require('undici')
-const handleRequest = require('../handle-request')
-const { URL } = require('node:url')
-const { convertHeadersToRaw } = require('../common')
-
-class NockClient extends undici.Client {
-  dispatch(options, handler) {
-    const url = new URL(options.path, options.origin)
-    if (options.query) {
-      url.search = new URLSearchParams(options.query).toString()
-    }
-
-    const decompressedRequest = new Request(url, {
-      method: options.method,
-      headers: options.headers,
-      body: options.body,
-      duplex: options.body ? 'half' : undefined,
-    })
-
-    handleRequest(decompressedRequest)
-      .then(async response => {
-        if (response) {
-          handler.onConnect?.(err => handler.onError(err), null)
-          handler.onHeaders?.(
-            response.status,
-            convertHeadersToRaw(response.headers),
-            () => {},
-            response.statusText,
-          )
-          handler.onData?.(Buffer.from(await response.arrayBuffer()))
-          handler.onComplete?.([]) // responseTrailers
-        } else {
-          const dispatcher = options.dispatcher || {
-            dispatch: super.dispatch.bind(this),
-          }
-          dispatcher.dispatch(options, handler)
-        }
-      })
-      .catch(err => {
-        handler.onError?.(err)
-      })
-  }
-}
-
-class NockAgent extends undici.Dispatcher {
-  constructor(options) {
-    super(options)
-
-    this.agent = new undici.Agent({ options, factory: this.factory.bind(this) })
-    this.originalOptions = options
-  }
-
-  dispatch(options, handler) {
-    this.agent.dispatch(options, handler)
-  }
-
-  factory(origin) {
-    const mockOptions = { ...this.originalOptions, agent: this }
-    return new NockClient(origin, mockOptions)
-  }
-}
-
-function activate() {
-  undici.setGlobalDispatcher(new NockAgent())
-}
-
-function deactivate() {
-  undici.setGlobalDispatcher(new undici.Agent())
-}
-
-module.exports = {
-  activate,
-  deactivate,
-}

package/lib/utils/node/index.js

@@ -1,33 +0,0 @@
-'use strict'
-const { Readable } = require('node:stream')
-
-const kDecompressedGetBody = Symbol('kDecompressedGetBody')
-
-/**
- * @param {Request} request
- * @returns {ArrayBuffer}
- * Returns the request body stream of the given request.
- * @note This is only relevant in the context of `http.ClientRequest`.
- * This function will throw if the given `request` wasn't created based on
- * the `http.ClientRequest` instance.
- * You must rely on the web stream consumers for other request clients.
- */
-function getDecompressedGetBody(request) {
-  if (request.method !== 'GET') {
-    throw new Error('The request method must be GET')
-  }
-  return Readable.from(Reflect.get(request, kDecompressedGetBody))
-}
-
-/**
- * @param {Request} request
- * @param {ArrayBuffer} body
- */
-function setDecompressedGetBody(request, body) {
-  Reflect.set(request, kDecompressedGetBody, Buffer.from(body))
-}
-
-module.exports = {
-  getDecompressedGetBody,
-  setDecompressedGetBody,
-}

package/types/index.d.ts

@@ -1,319 +0,0 @@
-// TypeScript Version: 5.0
-
-import { ReadStream } from 'fs'
-import { RequestOptions } from 'http'
-import { ParsedUrlQuery } from 'querystring'
-import { Readable } from 'stream'
-import { Url, URLSearchParams } from 'url'
-
-export = nock
-
-declare function nock(
-  basePath: string | RegExp | URL,
-  options?: nock.Options,
-): nock.Scope
-
-declare namespace nock {
-  function cleanAll(): void
-  function activate(): void
-  function isActive(): boolean
-  function isDone(): boolean
-  function pendingMocks(): string[]
-  function activeMocks(): string[]
-  function removeInterceptor(interceptor: Interceptor | ReqOptions): boolean
-  function disableNetConnect(): void
-  function enableNetConnect(
-    matcher?: string | RegExp | ((host: string) => boolean),
-  ): void
-  function load(path: string): Scope[]
-  function loadDefs(path: string): Definition[]
-  function define(defs: Definition[]): Scope[]
-  function restore(): void
-  function abortPendingRequests(): void
-
-  let back: Back
-  let emitter: NockEmitter
-  let recorder: Recorder
-
-  type InterceptFunction = (
-    uri: string | RegExp | { (uri: string): boolean },
-    requestBody?: RequestBodyMatcher,
-    interceptorOptions?: Options,
-  ) => Interceptor
-
-  // Essentially valid, decoded JSON with the addition of possible RegExp. TS doesn't currently have
-  // a great way to represent JSON type data, this data matcher design is based off this comment.
-  // https://github.com/microsoft/TypeScript/issues/1897#issuecomment-338650717
-  type DataMatcher =
-    | boolean
-    | number
-    | string
-    | null
-    | undefined
-    | RegExp
-    | DataMatcherArray
-    | DataMatcherMap
-  interface DataMatcherArray extends ReadonlyArray<DataMatcher> {}
-  interface DataMatcherMap {
-    [key: string]: DataMatcher
-  }
-
-  type RequestBodyMatcher =
-    | string
-    | Buffer
-    | RegExp
-    | DataMatcherArray
-    | DataMatcherMap
-    | { (body: any): boolean }
-
-  type RequestHeaderMatcher =
-    | string
-    | RegExp
-    | { (fieldValue: string): boolean }
-
-  type Body = string | Record<string, any> // a string or decoded JSON
-  type ReplyBody = Body | Buffer | ReadStream
-
-  type ReplyHeaderFunction = (req: Request) => Promise<string | string[]>
-  type ReplyHeaderValue = string | string[] | ReplyHeaderFunction
-  type ReplyHeaders =
-    | Record<string, ReplyHeaderValue>
-    | Map<string, ReplyHeaderValue>
-    | ReplyHeaderValue[]
-
-  type StatusCode = number
-  type ReplyFnResult =
-    | readonly [StatusCode]
-    | readonly [StatusCode, ReplyBody]
-    | readonly [StatusCode, ReplyBody, ReplyHeaders]
-
-  /**
-   * Detailed mismatch information for the 'no match' event
-   * @experimental This interface may change in future versions based on community feedback.
-   */
-  interface InterceptorMatchResult {
-    interceptor: Interceptor
-    reasons: string[]
-  }
-
-  /**
-   * Enhanced global emitter with typed 'no match' event
-   */
-  interface NockEmitter extends NodeJS.EventEmitter {
-    on(event: 'no match', listener: (req: Request) => void): this
-    on(
-      event: 'no match',
-      listener: (
-        req: Request,
-        interceptorResults?: InterceptorMatchResult[],
-      ) => void,
-    ): this
-    once(event: 'no match', listener: (req: Request) => void): this
-    once(
-      event: 'no match',
-      listener: (
-        req: Request,
-        interceptorResults?: InterceptorMatchResult[],
-      ) => void,
-    ): this
-    emit(
-      event: 'no match',
-      req: Request,
-      interceptorResults?: InterceptorMatchResult[],
-    ): boolean
-  }
-
-  interface Scope extends NodeJS.EventEmitter {
-    get: InterceptFunction
-    post: InterceptFunction
-    put: InterceptFunction
-    head: InterceptFunction
-    patch: InterceptFunction
-    merge: InterceptFunction
-    delete: InterceptFunction
-    options: InterceptFunction
-
-    intercept: (
-      uri: string | RegExp | { (uri: string): boolean },
-      method: string,
-      requestBody?: RequestBodyMatcher,
-      options?: Options,
-    ) => Interceptor
-
-    defaultReplyHeaders(headers: ReplyHeaders): this
-    matchHeader(name: string, value: RequestHeaderMatcher): this
-    filteringPath(regex: RegExp, replace: string): this
-    filteringPath(fn: (path: string) => string): this
-    filteringRequestBody(regex: RegExp, replace: string): this
-    filteringRequestBody(
-      fn: (body: string, recordedBody: string) => string,
-    ): this
-
-    persist(flag?: boolean): this
-    replyContentLength(): this
-    replyDate(d?: Date): this
-
-    done(): void
-    isDone(): boolean
-    pendingMocks(): string[]
-    activeMocks(): string[]
-  }
-
-  interface Interceptor {
-    query(
-      matcher:
-        | boolean
-        | string
-        | DataMatcherMap
-        | URLSearchParams
-        | { (parsedObj: ParsedUrlQuery): boolean },
-    ): this
-
-    // tslint (as of 5.16) is under the impression that the callback types can be unified,
-    // however, doing so causes the params to lose their inherited types during use.
-    // the order of the overrides is important for determining the param types in the replay fns.
-    /* tslint:disable:unified-signatures */
-    reply(
-      replyFnWithCallback: (
-        request: Request,
-        callback: (
-          err: NodeJS.ErrnoException | null,
-          result: ReplyFnResult,
-        ) => void,
-      ) => void,
-    ): Scope
-    reply(
-      replyFn: (request: Request) => ReplyFnResult | Promise<ReplyFnResult>,
-    ): Scope
-    reply(
-      statusCode: StatusCode,
-      replyBodyFnWithCallback: (
-        request: Request,
-        callback: (
-          err: NodeJS.ErrnoException | null,
-          result: ReplyBody,
-        ) => void,
-      ) => void,
-      headers?: ReplyHeaders,
-    ): Scope
-    reply(
-      statusCode: StatusCode,
-      replyBodyFn: (request: Request) => ReplyBody | Promise<ReplyBody>,
-      headers?: ReplyHeaders,
-    ): Scope
-    reply(responseCode?: StatusCode, body?: Body, headers?: ReplyHeaders): Scope
-    /* tslint:enable:unified-signatures */
-
-    replyWithError(errorMessage: string | object): Scope
-    replyWithFile(
-      statusCode: StatusCode,
-      fileName: string,
-      headers?: ReplyHeaders,
-    ): Scope
-
-    matchHeader(name: string, value: RequestHeaderMatcher): this
-    basicAuth(options: { user: string; pass?: string }): this
-
-    times(newCounter: number): this
-    once(): this
-    twice(): this
-    thrice(): this
-    optionally(flag?: boolean): this
-
-    delay(opts: number): this
-  }
-
-  /**
-   * Retrieves the decompressed body of a GET request.
-   * This function handles the edge case of GET requests with a body.
-   *
-   * @param request - The Request object.
-   * @returns A Promise resolving to the decompressed body.
-   */
-  function getDecompressedGetBody(request: Request): Promise<Readable>
-
-  interface Options {
-    allowUnmocked?: boolean
-    reqheaders?: Record<string, RequestHeaderMatcher>
-    badheaders?: string[]
-    filteringScope?: { (scope: string): boolean }
-    encodedQueryParams?: boolean
-  }
-
-  interface Recorder {
-    rec(options?: boolean | RecorderOptions): void
-    clear(): void
-    play(): string[] | Definition[]
-  }
-
-  interface RecorderOptions {
-    dont_print?: boolean
-    output_objects?: boolean
-    enable_reqheaders_recording?: boolean
-    logging?: (content: string) => void
-    use_separator?: boolean
-  }
-
-  interface Definition {
-    scope: string | RegExp
-    path: string | RegExp
-    port?: number | string
-    method?: string
-    status?: number
-    body?: RequestBodyMatcher
-    reqheaders?: Record<string, RequestHeaderMatcher>
-    response?: ReplyBody
-    headers?: ReplyHeaders
-    options?: Options
-  }
-
-  type BackMode = 'wild' | 'dryrun' | 'record' | 'update' | 'lockdown'
-
-  interface Back {
-    currentMode: BackMode
-    fixtures: string
-    setMode(mode: BackMode): void
-
-    (fixtureName: string, nockedFn: (nockDone: () => void) => void): void
-    (
-      fixtureName: string,
-      options: BackOptions,
-      nockedFn: (nockDone: () => void) => void,
-    ): void
-    (
-      fixtureName: string,
-      options?: BackOptions,
-    ): Promise<{
-      nockDone: () => void
-      context: BackContext
-    }>
-  }
-
-  interface InterceptorSurface {
-    method: string
-    uri: string
-    basePath: string
-    path: string
-    queries?: string
-    counter: number
-    body: string
-    statusCode: number
-    optional: boolean
-  }
-
-  interface BackContext {
-    isLoaded: boolean
-    scopes: Scope[]
-    assertScopesFinished(): void
-    query: InterceptorSurface[]
-  }
-
-  interface BackOptions {
-    before?: (def: Definition) => void
-    after?: (scope: Scope) => void
-    afterRecord?: (defs: Definition[]) => Definition[] | string
-    recorder?: RecorderOptions
-  }
-}
-
-type ReqOptions = RequestOptions & { proto?: string }