nock 11.3.6 → 11.7.0

package/README.md

@@ -58,6 +58,7 @@ For instance, if a module performs HTTP requests to a CouchDB server or makes HT
 - [Expectations](#expectations)
   - [.isDone()](#isdone)
   - [.cleanAll()](#cleanall)
+  - [.abortPendingRequests()](#abortpendingrequests)
   - [.persist()](#persist)
   - [.pendingMocks()](#pendingmocks)
   - [.activeMocks()](#activemocks)
@@ -995,6 +996,14 @@ You can cleanup all the prepared mocks (could be useful to cleanup some state af
 nock.cleanAll()
 ```
 
+### .abortPendingRequests()
+
+You can abort all current pending request like this:
+
+```js
+nock.abortPendingRequests()
+```
+
 ### .persist()
 
 You can make all the interceptors for a scope persist by calling `.persist()` on it:

package/index.js

@@ -12,6 +12,7 @@ const {
   disableNetConnect,
   enableNetConnect,
   removeAll,
+  abortPendingRequests,
 } = require('./lib/intercept')
 const recorder = require('./lib/recorder')
 const { Scope, load, loadDefs, define } = require('./lib/scope')
@@ -35,6 +36,7 @@ Object.assign(module.exports, {
     removeAll()
     return module.exports
   },
+  abortPendingRequests,
   load,
   loadDefs,
   define,

package/lib/common.js

@@ -3,6 +3,7 @@
 const _ = require('lodash')
 const debug = require('debug')('nock.common')
 const url = require('url')
+const timers = require('timers')
 
 /**
  * Normalizes the request options so that it always has `host` property.
@@ -37,23 +38,16 @@ function normalizeRequestOptions(options) {
 }
 
 /**
- * Returns false if the data contained in buffer can be reconstructed
+ * Returns true if the data contained in buffer can be reconstructed
  * from its utf8 representation.
  *
- * TODO: Reverse the semantics of this method and refactor calling code
- * accordingly. We've inadvertently gotten it flipped.
- *
  * @param  {Object} buffer - a Buffer object
  * @returns {boolean}
  */
 function isUtf8Representable(buffer) {
-  if (!Buffer.isBuffer(buffer)) {
-    return false
-  }
-
   const utfEncodedBuffer = buffer.toString('utf8')
   const reconstructedBuffer = Buffer.from(utfEncodedBuffer, 'utf8')
-  return !reconstructedBuffer.equals(buffer)
+  return reconstructedBuffer.equals(buffer)
 }
 
 //  Array where all information about all the overridden requests are held.
@@ -593,6 +587,32 @@ function deepEqual(expected, actual) {
   return expected === actual
 }
 
+const timeouts = []
+const intervals = []
+const immediates = []
+
+const wrapTimer = (timer, ids) => (...args) => {
+  const id = timer(...args)
+  ids.push(id)
+  return id
+}
+
+const setTimeout = wrapTimer(timers.setTimeout, timeouts)
+const setInterval = wrapTimer(timers.setInterval, intervals)
+const setImmediate = wrapTimer(timers.setImmediate, immediates)
+
+function clearTimer(clear, ids) {
+  while (ids.length) {
+    clear(ids.shift())
+  }
+}
+
+function removeAllTimers() {
+  clearTimer(clearTimeout, timeouts)
+  clearTimer(clearInterval, intervals)
+  clearTimer(clearImmediate, immediates)
+}
+
 exports.normalizeClientRequestArgs = normalizeClientRequestArgs
 exports.normalizeRequestOptions = normalizeRequestOptions
 exports.normalizeOrigin = normalizeOrigin
@@ -615,3 +635,7 @@ exports.matchStringOrRegexp = matchStringOrRegexp
 exports.formatQueryValue = formatQueryValue
 exports.isStream = isStream
 exports.dataEqual = dataEqual
+exports.setTimeout = setTimeout
+exports.setInterval = setInterval
+exports.setImmediate = setImmediate
+exports.removeAllTimers = removeAllTimers

package/lib/delayed_body.js

@@ -34,7 +34,7 @@ module.exports = class DelayedBody extends Transform {
 
     // TODO: This would be more readable if the stream case were moved into
     // the `if` statement above.
-    setTimeout(function() {
+    common.setTimeout(function() {
       if (common.isStream(body) && !ended) {
         body.once('end', function() {
           self.end(data)

package/lib/intercept.js

@@ -11,7 +11,6 @@ const http = require('http')
 const _ = require('lodash')
 const debug = require('debug')('nock.intercept')
 const globalEmitter = require('./global_emitter')
-const timers = require('timers')
 
 /**
  * @name NetConnectNotAllowedError
@@ -90,7 +89,7 @@ function isOff() {
 
 function addInterceptor(key, interceptor, scope, scopeOptions, host) {
   if (!(key in allInterceptors)) {
-    allInterceptors[key] = { key, scopes: [] }
+    allInterceptors[key] = { key, interceptors: [] }
   }
   interceptor.__nock_scope = scope
 
@@ -103,7 +102,7 @@ function addInterceptor(key, interceptor, scope, scopeOptions, host) {
 
   if (scopeOptions.allowUnmocked) allInterceptors[key].allowUnmocked = true
 
-  allInterceptors[key].scopes.push(interceptor)
+  allInterceptors[key].interceptors.push(interceptor)
 }
 
 function remove(interceptor) {
@@ -113,7 +112,7 @@ function remove(interceptor) {
 
   const { basePath } = interceptor
   const interceptors =
-    (allInterceptors[basePath] && allInterceptors[basePath].scopes) || []
+    (allInterceptors[basePath] && allInterceptors[basePath].interceptors) || []
 
   // TODO: There is a clearer way to write that we want to delete the first
   // matching instance. I'm also not sure why we couldn't delete _all_
@@ -125,7 +124,7 @@ function remove(interceptor) {
 
 function removeAll() {
   Object.keys(allInterceptors).forEach(function(key) {
-    allInterceptors[key].scopes.forEach(function(interceptor) {
+    allInterceptors[key].interceptors.forEach(function(interceptor) {
       interceptor.scope.keyedInterceptors = {}
     })
   })
@@ -146,32 +145,29 @@ function interceptorsFor(options) {
 
   debug('filtering interceptors for basepath', basePath)
 
-  //  First try to use filteringScope if any of the interceptors has it defined.
-  let matchingInterceptor
-  _.each(allInterceptors, function(interceptor) {
-    _.each(interceptor.scopes, function(scope) {
-      const { filteringScope } = scope.__nock_scopeOptions
+  // First try to use filteringScope if any of the interceptors has it defined.
+  for (const { key, interceptors, allowUnmocked } of Object.values(
+    allInterceptors
+  )) {
+    for (const interceptor of interceptors) {
+      const { filteringScope } = interceptor.__nock_scopeOptions
 
-      //  If scope filtering function is defined and returns a truthy value
-      //  then we have to treat this as a match.
+      // If scope filtering function is defined and returns a truthy value then
+      // we have to treat this as a match.
       if (filteringScope && filteringScope(basePath)) {
         debug('found matching scope interceptor')
 
-        //  Keep the filtered scope (its key) to signal the rest of the module
-        //  that this wasn't an exact but filtered match.
-        scope.__nock_filteredScope = scope.__nock_scopeKey
-        matchingInterceptor = interceptor.scopes
-        //  Break out of _.each for scopes.
-        return false
+        // Keep the filtered scope (its key) to signal the rest of the module
+        // that this wasn't an exact but filtered match.
+        interceptor.__nock_filteredScope = interceptor.__nock_scopeKey
+        return interceptors
       }
-    })
+    }
 
-    if (
-      !matchingInterceptor &&
-      common.matchStringOrRegexp(basePath, interceptor.key)
-    ) {
-      if (interceptor.scopes.length === 0 && interceptor.allowUnmocked) {
-        matchingInterceptor = [
+    if (common.matchStringOrRegexp(basePath, key)) {
+      if (allowUnmocked && interceptors.length === 0) {
+        debug('matched base path with allowUnmocked (no matching interceptors)')
+        return [
           {
             options: { allowUnmocked: true },
             matchAddress() {
@@ -180,18 +176,17 @@ function interceptorsFor(options) {
           },
         ]
       } else {
-        matchingInterceptor = interceptor.scopes
+        debug(
+          `matched base path (${interceptors.length} interceptor${
+            interceptors.length > 1 ? 's' : ''
+          })`
+        )
+        return interceptors
       }
-      // false to short circuit the .each
-      return false
     }
+  }
 
-    //  Returning falsy value here (which will happen if we have found our matching interceptor)
-    //  will break out of _.each for all interceptors.
-    return !matchingInterceptor
-  })
-
-  return matchingInterceptor
+  return undefined
 }
 
 function removeInterceptor(options) {
@@ -211,11 +206,14 @@ function removeInterceptor(options) {
     key = `${method} ${baseUrl}${options.path || '/'}`
   }
 
-  if (allInterceptors[baseUrl] && allInterceptors[baseUrl].scopes.length > 0) {
-    for (let i = 0; i < allInterceptors[baseUrl].scopes.length; i++) {
-      const interceptor = allInterceptors[baseUrl].scopes[i]
+  if (
+    allInterceptors[baseUrl] &&
+    allInterceptors[baseUrl].interceptors.length > 0
+  ) {
+    for (let i = 0; i < allInterceptors[baseUrl].interceptors.length; i++) {
+      const interceptor = allInterceptors[baseUrl].interceptors[i]
       if (interceptor._key === key) {
-        allInterceptors[baseUrl].scopes.splice(i, 1)
+        allInterceptors[baseUrl].interceptors.splice(i, 1)
         interceptor.scope.remove(key, interceptor)
         break
       }
@@ -294,7 +292,7 @@ function overrideClientRequest() {
       if (isOff() || isEnabledForNetConnect(options)) {
         originalClientRequest.apply(this, arguments)
       } else {
-        timers.setImmediate(
+        common.setImmediate(
           function() {
             const error = new NetConnectNotAllowedError(
               options.host,
@@ -337,7 +335,9 @@ function isActive() {
 }
 
 function interceptorScopes() {
-  const nestedInterceptors = Object.values(allInterceptors).map(i => i.scopes)
+  const nestedInterceptors = Object.values(allInterceptors).map(
+    i => i.interceptors
+  )
   return [].concat(...nestedInterceptors).map(i => i.scope)
 }
 
@@ -443,4 +443,5 @@ module.exports = {
   disableNetConnect,
   overrideClientRequest,
   restoreOverriddenClientRequest,
+  abortPendingRequests: common.removeAllTimers,
 }

package/lib/intercepted_request_router.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const debug = require('debug')('nock.request_overrider')
-const { EventEmitter } = require('events')
 const {
   IncomingMessage,
   ClientRequest,
@@ -9,7 +8,6 @@ const {
 } = require('http')
 const { request: originalHttpsRequest } = require('https')
 const propagate = require('propagate')
-const timers = require('timers')
 const common = require('./common')
 const globalEmitter = require('./global_emitter')
 const Socket = require('./socket')
@@ -32,8 +30,8 @@ class InterceptedRequestRouter {
     }
     this.interceptors = interceptors
 
-    this.response = new IncomingMessage(new EventEmitter())
-    this.socket = new Socket({ proto: options.proto })
+    this.socket = new Socket(options)
+    this.response = new IncomingMessage(this.socket)
     this.playbackStarted = false
     this.requestBodyBuffers = []
 
@@ -63,11 +61,8 @@ class InterceptedRequestRouter {
     // ClientRequest.connection is an alias for ClientRequest.socket
     // https://nodejs.org/api/http.html#http_request_socket
     // https://github.com/nodejs/node/blob/b0f75818f39ed4e6bd80eb7c4010c1daf5823ef7/lib/_http_client.js#L640-L641
-    // IncomingMessage.connection & IncomingMessage.client are aliases for IncomingMessage.socket
-    // https://nodejs.org/api/http.html#http_response_socket
-    // https://github.com/nodejs/node/blob/b0f75818f39ed4e6bd80eb7c4010c1daf5823ef7/lib/_http_incoming.js#L44-L69
     // The same Socket is shared between the request and response to mimic native behavior.
-    req.socket = req.connection = response.socket = response.client = response.connection = socket
+    req.socket = req.connection = socket
 
     propagate(['error', 'timeout'], req.socket, req)
 
@@ -78,7 +73,7 @@ class InterceptedRequestRouter {
 
     // https://github.com/nock/nock/issues/256
     if (options.headers.expect === '100-continue') {
-      timers.setImmediate(() => {
+      common.setImmediate(() => {
         debug('continue')
         req.emit('continue')
       })
@@ -125,7 +120,7 @@ class InterceptedRequestRouter {
       this.emitError(new Error('Request aborted'))
     }
 
-    timers.setImmediate(function() {
+    common.setImmediate(function() {
       req.emit('drain')
     })
 
@@ -236,8 +231,9 @@ class InterceptedRequestRouter {
       // Re-update `options` with the current value of `req.path` because badly
       // behaving agents like superagent like to change `req.path` mid-flight.
       path: req.path,
-      // similarly, node-http-proxy will modify headers in flight, so we have
+      // Similarly, node-http-proxy will modify headers in flight, so we have
       // to put the headers back into options.
+      // https://github.com/nock/nock/pull/1484
       headers: req.getHeaders(),
       // Fixes https://github.com/nock/nock/issues/976
       protocol: `${options.proto}:`,
@@ -250,11 +246,11 @@ class InterceptedRequestRouter {
     const requestBodyBuffer = Buffer.concat(this.requestBodyBuffers)
     // When request body is a binary buffer we internally use in its hexadecimal
     // representation.
-    const isBinaryRequestBodyBuffer = common.isUtf8Representable(
+    const requestBodyIsUtf8Representable = common.isUtf8Representable(
       requestBodyBuffer
     )
     const requestBodyString = requestBodyBuffer.toString(
-      isBinaryRequestBodyBuffer ? 'hex' : 'utf8'
+      requestBodyIsUtf8Representable ? 'utf8' : 'hex'
     )
 
     const matchedInterceptor = interceptors.find(i =>
@@ -269,7 +265,7 @@ class InterceptedRequestRouter {
         socket,
         options,
         requestBodyString,
-        isBinaryRequestBodyBuffer,
+        requestBodyIsUtf8Representable,
         response,
         interceptor: matchedInterceptor,
       })

package/lib/interceptor.js

@@ -31,10 +31,16 @@ module.exports = class Interceptor {
   constructor(scope, uri, method, requestBody, interceptorOptions) {
     const uriIsStr = typeof uri === 'string'
     // Check for leading slash. Uri can be either a string or a regexp, but
-    // we only need to check strings.
-    if (uriIsStr && /^[^/*]/.test(uri)) {
+    // When enabled filteringScope ignores the passed URL entirely so we skip validation.
+
+    if (
+      !scope.scopeOptions.filteringScope &&
+      uriIsStr &&
+      !uri.startsWith('/') &&
+      !uri.startsWith('*')
+    ) {
       throw Error(
-        "Non-wildcard URL path strings must begin with a slash (otherwise they won't match anything)"
+        `Non-wildcard URL path strings must begin with a slash (otherwise they won't match anything) (got: ${uri})`
       )
     }
 
@@ -224,7 +230,7 @@ module.exports = class Interceptor {
     }
 
     const method = (options.method || 'GET').toUpperCase()
-    let { path = '' } = options
+    let { path = '/' } = options
     let matches
     let matchKey
     const { proto } = options

package/lib/match_body.js

@@ -11,11 +11,8 @@ module.exports = function matchBody(options, spec, body) {
   }
 
   if (Buffer.isBuffer(spec)) {
-    if (common.isUtf8Representable(spec)) {
-      spec = spec.toString('hex')
-    } else {
-      spec = spec.toString('utf8')
-    }
+    const encoding = common.isUtf8Representable(spec) ? 'utf8' : 'hex'
+    spec = spec.toString(encoding)
   }
 
   const contentType = (

package/lib/playback_interceptor.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const util = require('util')
-const timers = require('timers')
 const zlib = require('zlib')
 const debug = require('debug')('nock.playback_interceptor')
 const _ = require('lodash')
@@ -81,7 +80,7 @@ function playbackInterceptor({
   socket,
   options,
   requestBodyString,
-  isBinaryRequestBodyBuffer,
+  requestBodyIsUtf8Representable,
   response,
   interceptor,
 }) {
@@ -106,7 +105,7 @@ function playbackInterceptor({
       } else {
         error = new Error(interceptor.errorMessage)
       }
-      timers.setTimeout(() => emitError(error), interceptor.getTotalDelay())
+      common.setTimeout(() => emitError(error), interceptor.getTotalDelay())
       return
     }
 
@@ -179,10 +178,10 @@ function playbackInterceptor({
     // will eventually be JSON stringified.
     let responseBody = interceptor.body
 
-    // If the request was binary then we assume that the response will be binary
-    // as well. In that case we send the response as a Buffer object as that's
-    // what the client will expect.
-    if (isBinaryRequestBodyBuffer && typeof responseBody === 'string') {
+    // If the request was not UTF8-representable then we assume that the
+    // response won't be either. In that case we send the response as a Buffer
+    // object as that's what the client will expect.
+    if (!requestBodyIsUtf8Representable && typeof responseBody === 'string') {
       // Try to create the buffer from the interceptor's body response as hex.
       responseBody = Buffer.from(responseBody, 'hex')
 
@@ -311,13 +310,13 @@ function playbackInterceptor({
         }
 
         // Stream the response chunks one at a time.
-        timers.setImmediate(function emitChunk() {
+        common.setImmediate(function emitChunk() {
           const chunk = responseBuffers.shift()
 
           if (chunk) {
             debug('emitting response chunk')
             response.push(chunk)
-            timers.setImmediate(emitChunk)
+            common.setImmediate(emitChunk)
           } else {
             debug('ending response stream')
             response.push(null)
@@ -338,7 +337,7 @@ function playbackInterceptor({
       interceptor.delayConnectionInMs > 0
     ) {
       socket.applyDelay(interceptor.delayConnectionInMs)
-      setTimeout(respond, interceptor.delayConnectionInMs)
+      common.setTimeout(respond, interceptor.delayConnectionInMs)
     } else {
       respond()
     }

package/lib/recorder.js

@@ -21,9 +21,9 @@ function getMethod(options) {
 }
 
 function getBodyFromChunks(chunks, headers) {
-  //  If we have headers and there is content-encoding it means that
-  //  the body shouldn't be merged but instead persisted as an array
-  //  of hex strings so that the responses can be mocked one by one.
+  // If we have headers and there is content-encoding it means that the body
+  // shouldn't be merged but instead persisted as an array of hex strings so
+  // that the response chunks can be mocked one by one.
   if (headers && common.isContentEncoded(headers)) {
     return {
       body: chunks.map(chunk => chunk.toString('hex')),
@@ -32,30 +32,29 @@ function getBodyFromChunks(chunks, headers) {
 
   const mergedBuffer = Buffer.concat(chunks)
 
-  //  The merged buffer can be one of three things:
-  //    1.  A binary buffer which then has to be recorded as a hex string.
-  //    2.  A string buffer which represents a JSON object.
-  //    3.  A string buffer which doesn't represent a JSON object.
-
-  const isBinary = common.isUtf8Representable(mergedBuffer)
-  if (isBinary) {
-    return {
-      body: mergedBuffer.toString('hex'),
-      isBinary: true,
-    }
-  } else {
+  // The merged buffer can be one of three things:
+  // 1. A UTF-8-representable string buffer which represents a JSON object.
+  // 2. A UTF-8-representable buffer which doesn't represent a JSON object.
+  // 3. A non-UTF-8-representable buffer which then has to be recorded as a hex string.
+  const isUtf8Representable = common.isUtf8Representable(mergedBuffer)
+  if (isUtf8Representable) {
     const maybeStringifiedJson = mergedBuffer.toString('utf8')
     try {
       return {
+        isUtf8Representable,
         body: JSON.parse(maybeStringifiedJson),
-        isBinary: false,
       }
     } catch (err) {
       return {
+        isUtf8Representable,
         body: maybeStringifiedJson,
-        isBinary: false,
       }
     }
+  } else {
+    return {
+      isUtf8Representable,
+      body: mergedBuffer.toString('hex'),
+    }
   }
 }
 
@@ -67,28 +66,26 @@ function generateRequestAndResponseObject({
   dataChunks,
   reqheaders,
 }) {
-  const response = getBodyFromChunks(dataChunks, res.headers)
+  const { body, isUtf8Representable } = getBodyFromChunks(
+    dataChunks,
+    res.headers
+  )
   options.path = req.path
 
-  const nockDef = {
+  return {
     scope: getScope(options),
     method: getMethod(options),
     path: options.path,
+    // Is it deliberate that `getBodyFromChunks()` is called a second time?
     body: getBodyFromChunks(bodyChunks).body,
     status: res.statusCode,
-    response: response.body,
+    response: body,
     rawHeaders: res.rawHeaders,
+    reqheaders: reqheaders || undefined,
+    // When content-encoding is enabled, isUtf8Representable is `undefined`,
+    // so we explicitly check for `false`.
+    responseIsBinary: isUtf8Representable === false,
   }
-
-  if (reqheaders) {
-    nockDef.reqheaders = reqheaders
-  }
-
-  if (response.isBinary) {
-    nockDef.responseIsBinary = true
-  }
-
-  return nockDef
 }
 
 function generateRequestAndResponse({

package/lib/scope.js

@@ -347,11 +347,12 @@ function define(nockDefs) {
       body = undefined
     }
 
-    //  Response is not always JSON as it could be a string or binary data or
-    //  even an array of binary buffers (e.g. when content is encoded)
+    // Response is not always JSON as it could be a string or binary data or
+    // even an array of binary buffers (e.g. when content is encoded).
     let response
     if (!nockDef.response) {
       response = ''
+      // TODO: Rename `responseIsBinary` to `reponseIsUtf8Representable`.
     } else if (nockDef.responseIsBinary) {
       response = Buffer.from(nockDef.response, 'hex')
     } else {

package/lib/socket.js

@@ -12,8 +12,10 @@ module.exports = class Socket extends EventEmitter {
       this.authorized = true
     }
 
+    this.bufferSize = 0
     this.writable = true
     this.readable = true
+    this.pending = false
     this.destroyed = false
     this.connecting = false
 
@@ -23,13 +25,27 @@ module.exports = class Socket extends EventEmitter {
     this.totalDelayMs = 0
     // Maximum allowed delay. Null means unlimited.
     this.timeoutMs = null
+
+    const ipv6 = options.family === 6
+    this.remoteFamily = ipv6 ? 'IPv6' : 'IPv4'
+    this.localAddress = this.remoteAddress = ipv6 ? '::1' : '127.0.0.1'
+    this.localPort = this.remotePort = parseInt(options.port)
   }
 
   setNoDelay() {}
   setKeepAlive() {}
   resume() {}
+  ref() {}
   unref() {}
 
+  address() {
+    return {
+      port: this.remotePort,
+      family: this.remoteFamily,
+      address: this.remoteAddress,
+    }
+  }
+
   setTimeout(timeoutMs, fn) {
     this.timeoutMs = timeoutMs
     if (fn) {