npm - nock - Versions diffs - 14.0.0-beta.9 → 14.0.0 - Mend

nock 14.0.0-beta.9 → 14.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -7,14 +7,6 @@
 [npmjs]: https://www.npmjs.com/package/nock
-> **Notice**
->
-> We have introduced experimental support for fetch. Please share your feedback with us. You can install it by:
->
-> ```
-> npm install --save-dev nock@beta
-> ```
 HTTP server mocking and expectations library for Node.js
 Nock can be used to test modules that perform HTTP requests in isolation.
@@ -692,46 +684,17 @@ You are able to specify the number of milliseconds that your reply should be del
 ```js
 nock('http://my.server.com')
   .get('/')
-  .delay(2000) // 2 seconds delay will be applied to the response header.
+  .delay(2000) // 2 seconds delay will be applied to the response body.
   .reply(200, '<html></html>')
 ```
-`delay(1000)` is an alias for `delayConnection(1000).delayBody(0)`
-`delay({ head: 1000, body: 2000 })` is an alias for `delayConnection(1000).delayBody(2000)`
-Both of which are covered in detail below.
 #### Delay the connection
-You are able to specify the number of milliseconds that your connection should be idle before it starts to receive the response.
-To simulate a socket timeout, provide a larger value than the timeout setting on the request.
-```js
-nock('http://my.server.com')
-  .get('/')
-  .delayConnection(2000) // 2 seconds
-  .reply(200, '<html></html>')
-req = http.request('http://my.server.com', { timeout: 1000 })
-```
-Nock emits timeout events almost immediately by comparing the requested connection delay to the timeout parameter passed to `http.request()` or `http.ClientRequest#setTimeout()`.
-This allows you to test timeouts without using fake timers or slowing down your tests.
-If the client chooses to _not_ take an action (e.g. abort the request), the request and response will continue on as normal, after real clock time has passed.
-##### Technical Details
-Following the `'finish'` event being emitted by `ClientRequest`, Nock will wait for the next event loop iteration before checking if the request has been aborted.
-At this point, any connection delay value is compared against any request timeout setting and a [`'timeout'`](https://nodejs.org/api/http.html#http_event_timeout) is emitted when appropriate from the socket and the request objects.
-A Node timeout timer is then registered with any connection delay value to delay real time before checking again if the request has been aborted and the [`'response'`](http://nodejs.org/api/http.html#http_event_response) is emitted by the request.
-A similar method, `.socketDelay()` was removed in version 13. It was thought that having two methods so subtlety similar was confusing.
-The discussion can be found at https://github.com/nock/nock/pull/1974.
+The `delayConnection` method’s behavior of emitting quick timeout events when the connection delay exceeds the request timeout is now deprecated. Please use the `delay` function instead.
 #### Delay the response body
-You are able to specify the number of milliseconds that the response body should be delayed.
-This is the time between the headers being received and the body starting to be received.
+The `delayBody` is now deprecated. Please use the `delay` function instead.
 ```js
 nock('http://my.server.com')

package/lib/common.js CHANGED Viewed

@@ -518,32 +518,36 @@ function deepEqual(expected, actual) {
   return expected === actual
 }
-const timeouts = []
-const intervals = []
-const immediates = []
+const timeouts = new Set()
+const immediates = new Set()
 const wrapTimer =
   (timer, ids) =>
-  (...args) => {
-    const id = timer(...args)
-    ids.push(id)
+  (callback, ...timerArgs) => {
+    const cb = (...callbackArgs) => {
+      try {
+        // eslint-disable-next-line n/no-callback-literal
+        callback(...callbackArgs)
+      } finally {
+        ids.delete(id)
+      }
+    }
+    const id = timer(cb, ...timerArgs)
+    ids.add(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())
-  }
+  ids.forEach(clear)
+  ids.clear()
 }
 function removeAllTimers() {
   debug('remove all timers')
   clearTimer(clearTimeout, timeouts)
-  clearTimer(clearInterval, intervals)
   clearTimer(clearImmediate, immediates)
 }
@@ -711,7 +715,6 @@ module.exports = {
   percentEncode,
   removeAllTimers,
   setImmediate,
-  setInterval,
   setTimeout,
   stringifyRequest,
   convertFetchRequestToClientRequest,

package/lib/create_response.js CHANGED Viewed

@@ -16,8 +16,9 @@ const responseStatusCodesWithoutBody = [204, 205, 304]
 /**
  * @param {import('http').IncomingMessage} message
+ * @param {AbortSignal} signal
  */
-function createResponse(message) {
+function createResponse(message, signal) {
   const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
     message.statusCode || 200,
   )
@@ -27,6 +28,7 @@ function createResponse(message) {
           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()

package/lib/intercept.js CHANGED Viewed

@@ -11,7 +11,6 @@ const http = require('http')
 const { intercept: debug } = require('./debug')
 const globalEmitter = require('./global_emitter')
 const { BatchInterceptor } = require('@mswjs/interceptors')
-const { FetchInterceptor } = require('@mswjs/interceptors/fetch')
 const {
   default: nodeInterceptors,
 } = require('@mswjs/interceptors/presets/node')
@@ -20,7 +19,7 @@ const { once } = require('events')
 const interceptor = new BatchInterceptor({
   name: 'nock-interceptor',
-  interceptors: [...nodeInterceptors, new FetchInterceptor()],
+  interceptors: nodeInterceptors,
 })
 let isNockActive = false
@@ -400,15 +399,7 @@ function activate() {
           globalEmitter.emit('no match', nockRequest)
         } else {
           nockRequest.on('response', nockResponse => {
-            // TODO: Consider put empty headers object as default when create the ClientRequest
-            if (nockResponse.req.headers) {
-              // forward Nock request headers to the MSW request
-              Object.entries(nockResponse.req.headers).map(([k, v]) =>
-                mswRequest.headers.set(k, v),
-              )
-            }
-            const response = createResponse(nockResponse)
+            const response = createResponse(nockResponse, mswRequest.signal)
             controller.respondWith(response)
           })

package/lib/recorder.js CHANGED Viewed

@@ -6,22 +6,18 @@ const { inspect } = require('util')
 const common = require('./common')
 const { restoreOverriddenClientRequest } = require('./intercept')
-const { BatchInterceptor } = require('@mswjs/interceptors')
-const { FetchInterceptor } = require('@mswjs/interceptors/fetch')
+const { EventEmitter } = require('stream')
+const { gzipSync, brotliCompressSync, deflateSync } = require('zlib')
 const {
   default: nodeInterceptors,
 } = require('@mswjs/interceptors/presets/node')
-const { EventEmitter } = require('stream')
 const SEPARATOR = '\n<<<<<<-- cut here -->>>>>>\n'
 let recordingInProgress = false
 let outputs = []
-// TODO: Consider use one BatchInterceptor (and not one for intercept and one for record)
-const interceptor = new BatchInterceptor({
-  name: 'nock-interceptor',
-  interceptors: [...nodeInterceptors, new FetchInterceptor()],
-})
+// TODO: don't reuse the nodeInterceptors, create new ones.
+const clientRequestInterceptor = nodeInterceptors[0]
+const fetchRequestInterceptor = nodeInterceptors[2]
 function getScope(options) {
   const { proto, host, port } = common.normalizeRequestOptions(options)
@@ -227,109 +223,137 @@ function record(recOptions) {
   restoreOverriddenClientRequest()
   //  We override the requests so that we can save information on them before executing.
-  interceptor.apply()
-  interceptor.on(
-    'request',
-    async function ({ request: mswRequest, requestId }) {
-      const request = mswRequest.clone()
-      const { options } = common.normalizeClientRequestArgs(request.url)
-      options.method = request.method
-      const proto = options.protocol.slice(0, -1)
-      // Node 0.11 https.request calls http.request -- don't want to record things
-      // twice.
-      /* istanbul ignore if */
-      if (options._recording) {
-        return
-      }
-      options._recording = true
-      const req = new EventEmitter()
-      req.on('response', function () {
-        debug(thisRecordingId, 'intercepting', proto, 'request to record')
-        // Intercept "res.once('end', ...)"-like event
-        interceptor.once(
-          'response',
-          async function ({ response: mswResponse }) {
-            const response = mswResponse.clone()
-            debug(thisRecordingId, proto, 'intercepted request ended')
-            let reqheaders
-            // Ignore request headers completely unless it was explicitly enabled by the user (see README)
-            if (enableReqHeadersRecording) {
-              // We never record user-agent headers as they are worse than useless -
-              // they actually make testing more difficult without providing any benefit (see README)
-              reqheaders = Object.fromEntries(request.headers.entries())
-              common.deleteHeadersField(reqheaders, 'user-agent')
-            }
+  clientRequestInterceptor.apply()
+  fetchRequestInterceptor.apply()
+  clientRequestInterceptor.on('request', async function ({ request }) {
+    await recordRequest(request)
+  })
+  fetchRequestInterceptor.on('request', async function ({ request }) {
+    await recordRequest(request)
+  })
-            const headers = Object.fromEntries(response.headers.entries())
-            const res = {
-              statusCode: response.status,
-              headers,
-              rawHeaders: headers,
-            }
+  async function recordRequest(mswRequest) {
+    const request = mswRequest.clone()
+    const { options } = common.normalizeClientRequestArgs(request.url)
+    options.method = request.method
+    const proto = options.protocol.slice(0, -1)
+    // Node 0.11 https.request calls http.request -- don't want to record things
+    // twice.
+    /* istanbul ignore if */
+    if (options._recording) {
+      return
+    }
+    options._recording = true
-            const generateFn = outputObjects
-              ? generateRequestAndResponseObject
-              : generateRequestAndResponse
-            let out = generateFn({
-              req: options,
-              bodyChunks: [Buffer.from(await request.arrayBuffer())],
-              options,
-              res,
-              dataChunks: [Buffer.from(await response.arrayBuffer())],
-              reqheaders,
-            })
-            debug('out:', out)
-            //  Check that the request was made during the current recording.
-            //  If it hasn't then skip it. There is no other simple way to handle
-            //  this as it depends on the timing of requests and responses. Throwing
-            //  will make some recordings/unit tests fail randomly depending on how
-            //  fast/slow the response arrived.
-            //  If you are seeing this error then you need to make sure that all
-            //  the requests made during a single recording session finish before
-            //  ending the same recording session.
-            if (thisRecordingId !== currentRecordingId) {
-              debug('skipping recording of an out-of-order request', out)
-              return
-            }
+    const req = new EventEmitter()
+    req.on('response', function () {
+      debug(thisRecordingId, 'intercepting', proto, 'request to record')
-            outputs.push(out)
-            if (!dontPrint) {
-              if (useSeparator) {
-                if (typeof out !== 'string') {
-                  out = JSON.stringify(out, null, 2)
-                }
-                logging(SEPARATOR + out + SEPARATOR)
-              } else {
-                logging(out)
-              }
-            }
-          },
-        )
+      clientRequestInterceptor.once('response', async function ({ response }) {
+        await recordResponse(response)
+      })
+      fetchRequestInterceptor.once('response', async function ({ response }) {
+        // fetch decompresses the body automatically, so we need to recompress it
+        const codings =
+          response.headers
+            .get('content-encoding')
+            ?.toLowerCase()
+            .split(',')
+            .map(c => c.trim()) || []
+        let body = await response.arrayBuffer()
+        for (const coding of codings) {
+          if (coding === 'gzip') {
+            body = gzipSync(body)
+          } else if (coding === 'deflate') {
+            body = deflateSync(body)
+          } else if (coding === 'br') {
+            body = brotliCompressSync(body)
+          }
+        }
-        debug('finished setting up intercepting')
+        await recordResponse(new Response(body, response))
+      })
-        // We override both the http and the https modules; when we are
-        // serializing the request, we need to know which was called.
-        // By stuffing the state, we can make sure that nock records
-        // the intended protocol.
-        if (proto === 'https') {
-          options.proto = 'https'
+      // Intercept "res.once('end', ...)"-like event
+      async function recordResponse(mswResponse) {
+        const response = mswResponse.clone()
+        debug(thisRecordingId, proto, 'intercepted request ended')
+        let reqheaders
+        // Ignore request headers completely unless it was explicitly enabled by the user (see README)
+        if (enableReqHeadersRecording) {
+          // We never record user-agent headers as they are worse than useless -
+          // they actually make testing more difficult without providing any benefit (see README)
+          reqheaders = Object.fromEntries(request.headers.entries())
+          common.deleteHeadersField(reqheaders, 'user-agent')
         }
-      })
-      // This is a massive change, we are trying to change minimum code, so we emit end event here
-      // because mswjs take care for these events
-      // TODO: refactor the recorder, we no longer need all the listeners and can just record the request we get from MSW
-      req.emit('response')
-    },
-  )
+        const headers = Object.fromEntries(response.headers.entries())
+        const res = {
+          statusCode: response.status,
+          headers,
+          rawHeaders: headers,
+        }
+        const generateFn = outputObjects
+          ? generateRequestAndResponseObject
+          : generateRequestAndResponse
+        let out = generateFn({
+          req: options,
+          bodyChunks: [Buffer.from(await request.arrayBuffer())],
+          options,
+          res,
+          dataChunks: [Buffer.from(await response.arrayBuffer())],
+          reqheaders,
+        })
+        debug('out:', out)
+        //  Check that the request was made during the current recording.
+        //  If it hasn't then skip it. There is no other simple way to handle
+        //  this as it depends on the timing of requests and responses. Throwing
+        //  will make some recordings/unit tests fail randomly depending on how
+        //  fast/slow the response arrived.
+        //  If you are seeing this error then you need to make sure that all
+        //  the requests made during a single recording session finish before
+        //  ending the same recording session.
+        if (thisRecordingId !== currentRecordingId) {
+          debug('skipping recording of an out-of-order request', out)
+          return
+        }
+        outputs.push(out)
+        if (!dontPrint) {
+          if (useSeparator) {
+            if (typeof out !== 'string') {
+              out = JSON.stringify(out, null, 2)
+            }
+            logging(SEPARATOR + out + SEPARATOR)
+          } else {
+            logging(out)
+          }
+        }
+      }
+      debug('finished setting up intercepting')
+      // We override both the http and the https modules; when we are
+      // serializing the request, we need to know which was called.
+      // By stuffing the state, we can make sure that nock records
+      // the intended protocol.
+      if (proto === 'https') {
+        options.proto = 'https'
+      }
+    })
+    // This is a massive change, we are trying to change minimum code, so we emit end event here
+    // because mswjs take care for these events
+    // TODO: refactor the recorder, we no longer need all the listeners and can just record the request we get from MSW
+    req.emit('response')
+  }
 }
 // Restore *all* the overridden http/https modules' properties.
@@ -339,7 +363,8 @@ function restore() {
     'restoring all the overridden http/https properties',
   )
-  interceptor.dispose()
+  clientRequestInterceptor.dispose()
+  fetchRequestInterceptor.dispose()
   restoreOverriddenClientRequest()
   recordingInProgress = false
 }

package/package.json CHANGED Viewed

@@ -7,7 +7,7 @@
     "testing",
     "isolation"
   ],
-  "version": "14.0.0-beta.9",
+  "version": "14.0.0",
   "author": "Pedro Teixeira <pedro.teixeira@gmail.com>",
   "repository": {
     "type": "git",
@@ -22,7 +22,7 @@
   "main": "./index.js",
   "types": "types",
   "dependencies": {
-    "@mswjs/interceptors": "^0.33.2",
+    "@mswjs/interceptors": "^0.37.3",
     "json-stringify-safe": "^5.0.1",
     "propagate": "^2.0.0"
   },
@@ -48,7 +48,7 @@
     "prettier": "3.2.5",
     "proxyquire": "^2.1.0",
     "rimraf": "^3.0.0",
-    "semantic-release": "^22.0.5",
+    "semantic-release": "^24.1.0",
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
     "typescript": "^5.0.4"

package/types/index.d.ts CHANGED Viewed

@@ -205,8 +205,13 @@ declare namespace nock {
     thrice(): this
     optionally(flag?: boolean): this
+    delay(opts: number): this
+    /** @deprecated use delay(number) instead */
+    delay(opts: { head?: number; body?: number }): this
     delay(opts: number | { head?: number; body?: number }): this
+    /** @deprecated use delay function instead */
     delayBody(timeMs: number): this
+    /** @deprecated use delay function instead */
     delayConnection(timeMs: number): this
   }
@@ -256,13 +261,13 @@ declare namespace nock {
     (
       fixtureName: string,
       options: BackOptions,
-      nockedFn: (nockDone: () => Promise<void>) => void,
+      nockedFn: (nockDone: () => void) => void,
     ): void
     (
       fixtureName: string,
       options?: BackOptions,
     ): Promise<{
-      nockDone: () => Promise<void>
+      nockDone: () => void
       context: BackContext
     }>
   }
@@ -289,7 +294,7 @@ declare namespace nock {
   interface BackOptions {
     before?: (def: Definition) => void
     after?: (scope: Scope) => void
-    afterRecord?: (defs: Definition[]) => Definition[]
+    afterRecord?: (defs: Definition[]) => Definition[] | string
     recorder?: RecorderOptions
   }
 }