nock 14.0.4 → 15.0.0-beta.1

package/README.md

@@ -1308,6 +1308,8 @@ Examples:
 nock.removeInterceptor({
   hostname: 'localhost',
   path: '/mockedResource',
+  // method defaults to `GET`
+  // proto defaults to `http`
 })
 ```
 

package/index.js

@@ -17,6 +17,7 @@ const {
 } = 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)
 
@@ -42,6 +43,7 @@ Object.assign(module.exports, {
   },
   restore: recorder.restore,
   back,
+  getDecompressedGetBody,
 })
 
 // We always activate Nock on import, overriding the globals.

package/lib/common.js

@@ -2,9 +2,8 @@
 
 const { common: debug } = require('./debug')
 const timers = require('timers')
-const url = require('url')
 const util = require('util')
-const http = require('http')
+const zlib = require('zlib')
 
 /**
  * Normalizes the request options so that it always has `host` property.
@@ -42,49 +41,48 @@ function normalizeRequestOptions(options) {
  * Returns true if the data contained in buffer can be reconstructed
  * from its utf8 representation.
  *
- * @param  {Object} buffer - a Buffer object
+ * @param  {ArrayBuffer} buffer
  * @returns {boolean}
  */
 function isUtf8Representable(buffer) {
-  const utfEncodedBuffer = buffer.toString('utf8')
-  const reconstructedBuffer = Buffer.from(utfEncodedBuffer, 'utf8')
-  return reconstructedBuffer.equals(buffer)
+  try {
+    new TextDecoder('utf8', { fatal: true }).decode(buffer)
+    return true
+  } catch {
+    return false
+  }
 }
 
 /**
  * In WHATWG URL vernacular, this returns the origin portion of a URL.
  * However, the port is not included if it's standard and not already present on the host.
+ *
+ * @param {URL} url
  */
-function normalizeOrigin(proto, host, port) {
-  const hostHasPort = host.includes(':')
-  const portIsStandard =
-    (proto === 'http' && (port === 80 || port === '80')) ||
-    (proto === 'https' && (port === 443 || port === '443'))
-  const portStr = hostHasPort || portIsStandard ? '' : `:${port}`
-
-  return `${proto}://${host}${portStr}`
+function normalizeOrigin(url) {
+  // Remove brackets from hostname if IPV6
+  const normalizedOrigin = url.hostname.startsWith('[')
+    ? `${url.protocol}//${url.hostname.slice(1, -1)}${url.port ? `:${url.port}` : ''}`
+    : url.origin
+  if (url.port) {
+    return normalizedOrigin
+  } else {
+    return normalizedOrigin + (url.protocol === 'http:' ? ':80' : ':443')
+  }
 }
 
 /**
  * Get high level information about request as string
- * @param  {Object} options
- * @param  {string} options.method
- * @param  {number|string} options.port
- * @param  {string} options.proto Set internally. always http or https
- * @param  {string} options.hostname
- * @param  {string} options.path
- * @param  {Object} options.headers
+ * @param  {Request} request
  * @param  {string} body
- * @return {string}
  */
-function stringifyRequest(options, body) {
-  const { method = 'GET', path = '', port } = options
-  const origin = normalizeOrigin(options.proto, options.hostname, port)
+function stringifyRequest(request, body) {
+  const url = new URL(request.url)
 
   const log = {
-    method,
-    url: `${origin}${path}`,
-    headers: options.headers,
+    method: request.method,
+    url: `${url.origin}${url.pathname}`,
+    headers: Object.fromEntries(request.headers.entries()),
   }
 
   if (body) {
@@ -99,14 +97,22 @@ function isContentEncoded(headers) {
   return typeof contentEncoding === 'string' && contentEncoding !== ''
 }
 
+/**
+ * @param {Headers} headers
+ * @param {'gzip' | 'deflate'} encoder
+ * @returns
+ */
 function contentEncoding(headers, encoder) {
-  const contentEncoding = headers['content-encoding']
-  return contentEncoding !== undefined && contentEncoding.toString() === encoder
+  const contentEncoding = headers.get('content-encoding')
+  return contentEncoding?.toString() === encoder
 }
 
+/**
+ * @param {Headers} headers
+ */
 function isJSONContent(headers) {
   // https://tools.ietf.org/html/rfc8259
-  const contentType = String(headers['content-type'] || '').toLowerCase()
+  const contentType = String(headers.get('content-type') || '').toLowerCase()
   return contentType.startsWith('application/json')
 }
 
@@ -409,65 +415,6 @@ function isStream(obj) {
   )
 }
 
-/**
- * Converts the arguments from the various signatures of http[s].request into a standard
- * options object and an optional callback function.
- *
- * https://nodejs.org/api/http.html#http_http_request_url_options_callback
- *
- * Taken from the beginning of the native `ClientRequest`.
- * https://github.com/nodejs/node/blob/908292cf1f551c614a733d858528ffb13fb3a524/lib/_http_client.js#L68
- */
-function normalizeClientRequestArgs(input, options, cb) {
-  if (typeof input === 'string') {
-    input = urlToOptions(new url.URL(input))
-  } else if (input instanceof url.URL) {
-    input = urlToOptions(input)
-  } else {
-    cb = options
-    options = input
-    input = null
-  }
-
-  if (typeof options === 'function') {
-    cb = options
-    options = input || {}
-  } else {
-    options = Object.assign(input || {}, options)
-  }
-
-  return { options, callback: cb }
-}
-
-/**
- * Utility function that converts a URL object into an ordinary
- * options object as expected by the http.request and https.request APIs.
- *
- * This was copied from Node's source
- * https://github.com/nodejs/node/blob/908292cf1f551c614a733d858528ffb13fb3a524/lib/internal/url.js#L1257
- */
-function urlToOptions(url) {
-  const options = {
-    protocol: url.protocol,
-    hostname:
-      typeof url.hostname === 'string' && url.hostname.startsWith('[')
-        ? url.hostname.slice(1, -1)
-        : url.hostname,
-    hash: url.hash,
-    search: url.search,
-    pathname: url.pathname,
-    path: `${url.pathname}${url.search || ''}`,
-    href: url.href,
-  }
-  if (url.port !== '') {
-    options.port = Number(url.port)
-  }
-  if (url.username || url.password) {
-    options.auth = `${url.username}:${url.password}`
-  }
-  return options
-}
-
 /**
  * Determines if request data matches the expected schema.
  *
@@ -551,59 +498,6 @@ function removeAllTimers() {
   clearTimer(clearImmediate, immediates)
 }
 
-/**
- * Check if the Client Request has been cancelled.
- *
- * Until Node 14 is the minimum, we need to look at both flags to see if the request has been cancelled.
- * The two flags have the same purpose, but the Node maintainers are migrating from `abort(ed)` to
- * `destroy(ed)` terminology, to be more consistent with `stream.Writable`.
- * In Node 14.x+, Calling `abort()` will set both `aborted` and `destroyed` to true, however,
- * calling `destroy()` will only set `destroyed` to true.
- * Falling back on checking if the socket is destroyed to cover the case of Node <14.x where
- * `destroy()` is called, but `destroyed` is undefined.
- *
- * Node Client Request history:
- * - `request.abort()`: Added in: v0.3.8, Deprecated since: v14.1.0, v13.14.0
- * - `request.aborted`: Added in: v0.11.14, Became a boolean instead of a timestamp: v11.0.0, Not deprecated (yet)
- * - `request.destroy()`: Added in: v0.3.0
- * - `request.destroyed`: Added in: v14.1.0, v13.14.0
- *
- * @param {ClientRequest} req
- * @returns {boolean}
- */
-function isRequestDestroyed(req) {
-  return !!(
-    req.destroyed === true ||
-    req.aborted ||
-    (req.socket && req.socket.destroyed)
-  )
-}
-
-/**
- * @param {Request} request
- */
-function convertFetchRequestToClientRequest(request) {
-  const url = new URL(request.url)
-  const options = {
-    ...urlToOptions(url),
-    method: request.method,
-    host: url.hostname,
-    port: url.port || (url.protocol === 'https:' ? 443 : 80),
-    path: url.pathname + url.search,
-    proto: url.protocol.slice(0, -1),
-    headers: Object.fromEntries(request.headers.entries()),
-  }
-
-  // By default, Node adds a host header, but for maximum backward compatibility, we are now removing it.
-  // However, we need to consider leaving the header and fixing the tests.
-  if (options.headers.host === options.host) {
-    const { host, ...restHeaders } = options.headers
-    options.headers = restHeaders
-  }
-
-  return new http.ClientRequest(options)
-}
-
 /**
  * Returns true if the given value is a plain object and not an Array.
  * @param {*} value
@@ -690,6 +584,40 @@ const expand = input => {
   return result
 }
 
+/**
+ * @param {ArrayBuffer} buffer
+ * @param {string} contentEncoding
+ */
+function decompressRequestBody(buffer, contentEncoding) {
+  const encodings = contentEncoding
+    .toLowerCase()
+    .split(',')
+    .map(coding => coding.trim())
+
+  for (const encoding of encodings) {
+    if (encoding === 'gzip') {
+      return zlib.gunzipSync(buffer)
+    } else if (encoding === 'deflate') {
+      return zlib.inflateSync(buffer)
+    } else if (encoding === 'br') {
+      return zlib.brotliDecompressSync(buffer)
+    }
+  }
+
+  return buffer
+}
+
+/**
+ * @param {Headers} headers
+ */
+function convertHeadersToRaw(headers) {
+  const rawHeaders = []
+  for (const [name, value] of headers.entries()) {
+    rawHeaders.push(name, value)
+  }
+  return rawHeaders
+}
+
 module.exports = {
   contentEncoding,
   dataEqual,
@@ -704,11 +632,9 @@ module.exports = {
   isContentEncoded,
   isJSONContent,
   isPlainObject,
-  isRequestDestroyed,
   isStream,
   isUtf8Representable,
   matchStringOrRegexp,
-  normalizeClientRequestArgs,
   normalizeOrigin,
   normalizeRequestOptions,
   percentDecode,
@@ -717,5 +643,6 @@ module.exports = {
   setImmediate,
   setTimeout,
   stringifyRequest,
-  convertFetchRequestToClientRequest,
+  decompressRequestBody,
+  convertHeadersToRaw,
 }

package/lib/global_emitter.js

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

package/lib/handle-request.js

@@ -0,0 +1,107 @@
+'use strict'
+const { inherits } = require('node:util')
+const globalEmitter = require('./global_emitter')
+const common = require('./common')
+const { playbackInterceptor } = require('./playback_interceptor')
+
+/**
+ * @param {Request} request
+ */
+async function handleRequest(request) {
+  const {
+    interceptorsFor,
+    isOn,
+    isEnabledForNetConnect,
+  } = require('./intercept')
+  const url = new URL(request.url)
+  const interceptors = interceptorsFor(url)
+
+  if (isOn() && interceptors) {
+    const matches = interceptors.some(interceptor =>
+      interceptor.matchOrigin(request),
+    )
+    const allowUnmocked = interceptors.some(
+      interceptor => interceptor.options.allowUnmocked,
+    )
+    if (!matches && allowUnmocked) {
+      globalEmitter.emit('no match', request)
+    } else {
+      const requestBodyBuffer = await request.clone().arrayBuffer()
+      // When request body is a binary buffer we internally use in its hexadecimal representation.
+      const requestBodyIsUtf8Representable =
+        common.isUtf8Representable(requestBodyBuffer)
+      const requestBodyString = Buffer.from(requestBodyBuffer).toString(
+        requestBodyIsUtf8Representable ? 'utf8' : 'hex',
+      )
+
+      const matchedInterceptor = interceptors.find(i =>
+        i.match(request, requestBodyString),
+      )
+
+      if (matchedInterceptor) {
+        matchedInterceptor.scope.logger(
+          'interceptor identified, starting mocking',
+        )
+
+        matchedInterceptor.markConsumed()
+
+        const response = await playbackInterceptor({
+          decompressedRequest: request,
+          requestBodyString,
+          interceptor: matchedInterceptor,
+          requestBodyIsUtf8Representable,
+        })
+
+        return response
+      } else {
+        globalEmitter.emit('no match', request)
+
+        // Try to find a hostname match that allows unmocked.
+        const allowUnmocked = interceptors.some(
+          i => i.matchHostName(url.hostname) && i.options.allowUnmocked,
+        )
+
+        if (!allowUnmocked) {
+          const reqStr = common.stringifyRequest(request, requestBodyString)
+          const err = new Error(`Nock: No match for request ${reqStr}`)
+          err.code = 'ERR_NOCK_NO_MATCH'
+          err.statusCode = err.status = 404
+          throw err
+        }
+      }
+    }
+  } else {
+    globalEmitter.emit('no match', request)
+    // Remove http(s):// for backward compatibility until we decide this Error.
+    const normalizedUrl = common
+      .normalizeOrigin(url)
+      .replace(`${url.protocol}//`, '')
+    if (isOn() && !isEnabledForNetConnect(normalizedUrl)) {
+      throw new NetConnectNotAllowedError(normalizedUrl, url.pathname)
+    }
+  }
+}
+
+/**
+ * @name NetConnectNotAllowedError
+ * @private
+ * @desc Error trying to make a connection when disabled external access.
+ * @class
+ * @example
+ * nock.disableNetConnect();
+ * http.get('http://zombo.com');
+ * // throw NetConnectNotAllowedError
+ */
+function NetConnectNotAllowedError(host, path) {
+  Error.call(this)
+
+  this.name = 'NetConnectNotAllowedError'
+  this.code = 'ENETUNREACH'
+  this.message = `Nock: Disallowed net connect for "${host}${path}"`
+
+  Error.captureStackTrace(this, this.constructor)
+}
+
+inherits(NetConnectNotAllowedError, Error)
+
+module.exports = handleRequest