nock 14.0.0-beta.7 → 14.0.0-beta.8

package/lib/back.js

@@ -77,7 +77,6 @@ function Back(fixtureName, options, nockedFn) {
   }
 
   debug('context:', context)
-
   // If nockedFn is a function then invoke it, otherwise return a promise resolving to nockDone.
   if (typeof nockedFn === 'function') {
     nockedFn.call(context, nockDone)

package/lib/common.js

@@ -4,6 +4,7 @@ const { common: debug } = require('./debug')
 const timers = require('timers')
 const url = require('url')
 const util = require('util')
+const http = require('http')
 
 /**
  * Normalizes the request options so that it always has `host` property.
@@ -50,82 +51,6 @@ function isUtf8Representable(buffer) {
   return reconstructedBuffer.equals(buffer)
 }
 
-//  Array where all information about all the overridden requests are held.
-let requestOverrides = {}
-
-/**
- * Overrides the current `request` function of `http` and `https` modules with
- * our own version which intercepts issues HTTP/HTTPS requests and forwards them
- * to the given `newRequest` function.
- *
- * @param  {Function} newRequest - a function handling requests; it accepts four arguments:
- *   - proto - a string with the overridden module's protocol name (either `http` or `https`)
- *   - overriddenRequest - the overridden module's request function already bound to module's object
- *   - options - the options of the issued request
- *   - callback - the callback of the issued request
- */
-function overrideRequests(newRequest) {
-  debug('overriding requests')
-  ;['http', 'https'].forEach(function (proto) {
-    debug('- overriding request for', proto)
-
-    const moduleName = proto // 1 to 1 match of protocol and module is fortunate :)
-    const module = require(proto)
-    const overriddenRequest = module.request
-    const overriddenGet = module.get
-
-    if (requestOverrides[moduleName]) {
-      throw new Error(
-        `Module's request already overridden for ${moduleName} protocol.`,
-      )
-    }
-
-    //  Store the properties of the overridden request so that it can be restored later on.
-    requestOverrides[moduleName] = {
-      module,
-      request: overriddenRequest,
-      get: overriddenGet,
-    }
-    // https://nodejs.org/api/http.html#http_http_request_url_options_callback
-    module.request = function (input, options, callback) {
-      return newRequest(proto, overriddenRequest.bind(module), [
-        input,
-        options,
-        callback,
-      ])
-    }
-    // https://nodejs.org/api/http.html#http_http_get_options_callback
-    module.get = function (input, options, callback) {
-      const req = newRequest(proto, overriddenGet.bind(module), [
-        input,
-        options,
-        callback,
-      ])
-      req.end()
-      return req
-    }
-
-    debug('- overridden request for', proto)
-  })
-}
-
-/**
- * Restores `request` function of `http` and `https` modules to values they
- * held before they were overridden by us.
- */
-function restoreOverriddenRequests() {
-  debug('restoring requests')
-  Object.entries(requestOverrides).forEach(
-    ([proto, { module, request, get }]) => {
-      debug('- restoring request for', proto)
-      module.request = request
-      module.get = get
-      debug('- restored request for', proto)
-    },
-  )
-  requestOverrides = {}
-}
-
 /**
  * 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.
@@ -616,6 +541,7 @@ function clearTimer(clear, ids) {
 }
 
 function removeAllTimers() {
+  debug('remove all timers')
   clearTimer(clearTimeout, timeouts)
   clearTimer(clearInterval, intervals)
   clearTimer(clearImmediate, immediates)
@@ -649,6 +575,31 @@ function isRequestDestroyed(req) {
   )
 }
 
+/**
+ * @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
@@ -735,24 +686,6 @@ const expand = input => {
   return result
 }
 
-/**
- * @param {Request} request
- */
-function convertFetchRequestToOptions(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()),
-  }
-
-  return options
-}
-
 module.exports = {
   contentEncoding,
   dataEqual,
@@ -774,14 +707,12 @@ module.exports = {
   normalizeClientRequestArgs,
   normalizeOrigin,
   normalizeRequestOptions,
-  overrideRequests,
   percentDecode,
   percentEncode,
   removeAllTimers,
-  restoreOverriddenRequests,
   setImmediate,
   setInterval,
   setTimeout,
   stringifyRequest,
-  convertFetchRequestToClientRequest: convertFetchRequestToOptions,
+  convertFetchRequestToClientRequest,
 }

package/lib/create_response.js

@@ -1,9 +1,6 @@
 'use strict'
 
-const zlib = require('node:zlib')
-const { headersArrayToObject } = require('./common')
 const { STATUS_CODES } = require('http')
-const { pipeline, Readable } = require('node:stream')
 
 /**
  * Creates a Fetch API `Response` instance from the given
@@ -18,79 +15,37 @@ const { pipeline, Readable } = require('node:stream')
 const responseStatusCodesWithoutBody = [204, 205, 304]
 
 /**
- * @param {import('node:http').IncomingMessage} message
+ * @param {import('http').IncomingMessage} message 
  */
 function createResponse(message) {
-  // https://github.com/Uzlopak/undici/blob/main/lib/fetch/index.js#L2031
-  const decoders = []
-  const codings =
-    message.headers['content-encoding']
-      ?.toLowerCase()
-      .split(',')
-      .map(x => x.trim())
-      .reverse() || []
-  for (const coding of codings) {
-    if (coding === 'gzip' || coding === 'x-gzip') {
-      decoders.push(
-        zlib.createGunzip({
-          flush: zlib.constants.Z_SYNC_FLUSH,
-          finishFlush: zlib.constants.Z_SYNC_FLUSH,
-        }),
-      )
-    } else if (coding === 'deflate') {
-      decoders.push(zlib.createInflate())
-    } else if (coding === 'br') {
-      decoders.push(zlib.createBrotliDecompress())
-    } else {
-      decoders.length = 0
-      break
-    }
-  }
-
-  let isCanceled = false
-  const chunks = []
   const responseBodyOrNull = responseStatusCodesWithoutBody.includes(
-    message.statusCode,
+    message.statusCode || 200
   )
     ? null
     : new ReadableStream({
-        start(controller) {
-          message.on('data', chunk => chunks.push(chunk))
-          message.on('end', () => {
-            pipeline(
-              Readable.from(chunks),
-              ...decoders,
-              async function* (source) {
-                for await (const chunk of source) {
-                  yield controller.enqueue(chunk)
-                }
-              },
-              error => {
-                if (error) {
-                  controller.error(error)
-                } else if (!isCanceled) {
-                  controller.close()
-                }
-              },
-            )
-          })
-
-          /**
-           * @todo Should also listen to the "error" on the message
-           * and forward it to the controller. Otherwise the stream
-           * will pend indefinitely.
-           */
-        },
-        cancel() {
-          isCanceled = true
-        },
-      })
+      start(controller) {
+        message.on('data', (chunk) => controller.enqueue(chunk))
+        message.on('end', () => controller.close())
+        message.on('error', (error) => controller.error(error))
+      },
+      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])
+  }
 
-  return new Response(responseBodyOrNull, {
+  // @mswjs/interceptors supports rawHeaders. https://github.com/mswjs/interceptors/pull/598
+  const response = new Response(responseBodyOrNull, {
     status: message.statusCode,
-    statusText: STATUS_CODES[message.statusCode],
-    headers: headersArrayToObject(message.rawHeaders),
+    statusText: message.statusMessage || STATUS_CODES[message.statusCode],
+    headers: rawHeaders,
   })
+
+  return response
 }
 
 module.exports = { createResponse }

package/lib/intercept.js

@@ -10,7 +10,17 @@ const { inherits } = require('util')
 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')
 const { createResponse } = require('./create_response')
+const { once } = require('events')
+
+const interceptor = new BatchInterceptor({
+  name: 'nock-interceptor',
+  interceptors: [...nodeInterceptors, new FetchInterceptor()],
+})
+let isNockActive = false
 
 /**
  * @name NetConnectNotAllowedError
@@ -184,8 +194,7 @@ function interceptorsFor(options) {
         ]
       } else {
         debug(
-          `matched base path (${interceptors.length} interceptor${
-            interceptors.length > 1 ? 's' : ''
+          `matched base path (${interceptors.length} interceptor${interceptors.length > 1 ? 's' : ''
           })`,
         )
         return interceptors
@@ -238,19 +247,6 @@ function removeInterceptor(options) {
 //  Variable where we keep the ClientRequest we have overridden
 //  (which might or might not be node's original http.ClientRequest)
 let originalClientRequest
-//  Variable where we keep the fetch we have overridden
-let originalFetch
-
-function ErroringClientRequest(error) {
-  http.OutgoingMessage.call(this)
-  process.nextTick(
-    function () {
-      this.emit('error', error)
-    }.bind(this),
-  )
-}
-
-inherits(ErroringClientRequest, http.ClientRequest)
 
 function overrideClientRequest() {
   // Here's some background discussion about overriding ClientRequest:
@@ -305,9 +301,7 @@ function overrideClientRequest() {
 
       //  Fallback to original ClientRequest if nock is off or the net connection is enabled.
       if (isOff() || isEnabledForNetConnect(options)) {
-        if (options.isFetchRequest === undefined) {
-          originalClientRequest.apply(this, arguments)
-        }
+        originalClientRequest.apply(this, arguments)
       } else {
         common.setImmediate(
           function () {
@@ -338,27 +332,25 @@ function restoreOverriddenClientRequest() {
   if (!originalClientRequest) {
     debug('- ClientRequest was not overridden')
   } else {
+    isNockActive = false;
+    interceptor.dispose()
     http.ClientRequest = originalClientRequest
     originalClientRequest = undefined
 
-    global.fetch = originalFetch
-    originalFetch = undefined
-
     debug('- ClientRequest restored')
   }
 }
 
 function isActive() {
-  //  If ClientRequest has been overwritten by Nock then originalClientRequest is not undefined.
-  //  This means that Nock has been activated.
-  return originalClientRequest !== undefined
+  return isNockActive
 }
 
 function interceptorScopes() {
   const nestedInterceptors = Object.values(allInterceptors).map(
     i => i.interceptors,
   )
-  return [].concat(...nestedInterceptors).map(i => i.scope)
+  const scopes = new Set([].concat(...nestedInterceptors).map(i => i.scope))
+  return [...scopes]
 }
 
 function isDone() {
@@ -374,97 +366,64 @@ function activeMocks() {
 }
 
 function activate() {
-  if (originalClientRequest) {
+  if (isNockActive) {
     throw new Error('Nock already active')
   }
 
-  // ----- Overriding http.request and https.request:
-
-  common.overrideRequests(function (proto, overriddenRequest, args) {
-    //  NOTE: overriddenRequest is already bound to its module.
-
-    const { options, callback } = common.normalizeClientRequestArgs(...args)
-
-    if (Object.keys(options).length === 0) {
-      // As weird as it is, it's possible to call `http.request` without
-      // options, and it makes a request to localhost or somesuch. We should
-      // support it too, for parity. However it doesn't work today, and fixing
-      // it seems low priority. Giving an explicit error is nicer than
-      // crashing with a weird stack trace. `new ClientRequest()`, nock's
-      // other client-facing entry point, makes a similar check.
-      // https://github.com/nock/nock/pull/1386
-      // https://github.com/nock/nock/pull/1440
-      throw Error(
-        'Making a request with empty `options` is not supported in Nock',
-      )
-    }
-
-    // The option per the docs is `protocol`. Its unclear if this line is meant to override that and is misspelled or if
-    // the intend is to explicitly keep track of which module was called using a separate name.
-    // Either way, `proto` is used as the source of truth from here on out.
-    options.proto = proto
-
+  overrideClientRequest()
+  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: mswRequest, controller }) {
+    const request = mswRequest.clone()
+    const { options } = common.normalizeClientRequestArgs(request.url)
+    options.proto = options.protocol.slice(0, -1)
+    options.method = request.method
     const interceptors = interceptorsFor(options)
-
     if (isOn() && interceptors) {
       const matches = interceptors.some(interceptor =>
-        interceptor.matchOrigin(options),
+        interceptor.matchOrigin(options)
       )
       const allowUnmocked = interceptors.some(
-        interceptor => interceptor.options.allowUnmocked,
+        interceptor => interceptor.options.allowUnmocked
       )
 
+      const nockRequest = common.convertFetchRequestToClientRequest(request);
       if (!matches && allowUnmocked) {
-        let req
-        if (proto === 'https') {
-          const { ClientRequest } = http
-          http.ClientRequest = originalClientRequest
-          req = overriddenRequest(options, callback)
-          http.ClientRequest = ClientRequest
-        } else {
-          req = overriddenRequest(options, callback)
-        }
-        globalEmitter.emit('no match', req)
-        return req
-      }
+        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)
+          controller.respondWith(response)
+        })
 
-      //  NOTE: Since we already overrode the http.ClientRequest we are in fact constructing
-      //    our own OverriddenClientRequest.
-      return new http.ClientRequest(options, callback)
+        const promise = Promise.race([
+          // TODO: temp hacky way to handle allowUnmocked in startPlayback
+          once(nockRequest, 'real-request'),
+          once(nockRequest, 'error'),
+          once(nockRequest, 'response'),
+        ])
+        const buffer = await request.arrayBuffer()
+        nockRequest.write(buffer)
+        nockRequest.end()
+        await promise
+      }
     } else {
       globalEmitter.emit('no match', options)
-      if (isOff() || isEnabledForNetConnect(options)) {
-        return overriddenRequest(options, callback)
-      } else {
-        const error = new NetConnectNotAllowedError(options.host, options.path)
-        return new ErroringClientRequest(error)
+      if (!(isOff() || isEnabledForNetConnect(options))) {
+        throw new NetConnectNotAllowedError(options.host, options.path)
       }
     }
   })
-
-  originalFetch = global.fetch
-  global.fetch = async (input, init = undefined) => {
-    const request = new Request(input, init)
-    const options = common.convertFetchRequestToClientRequest(request)
-    options.isFetchRequest = true
-    const body = await request.arrayBuffer()
-    const clientRequest = new http.ClientRequest(options)
-
-    // If mock found
-    if (clientRequest.interceptors) {
-      return new Promise((resolve, reject) => {
-        clientRequest.on('response', response => {
-          resolve(createResponse(response))
-        })
-        clientRequest.on('error', reject)
-        clientRequest.end(body)
-      })
-    } else {
-      return originalFetch(input, init)
-    }
-  }
-
-  overrideClientRequest()
+  isNockActive = true
 }
 
 module.exports = {

package/lib/intercepted_request_router.js

@@ -4,9 +4,7 @@ const { request_overrider: debug } = require('./debug')
 const {
   IncomingMessage,
   ClientRequest,
-  request: originalHttpRequest,
 } = require('http')
-const { request: originalHttpsRequest } = require('https')
 const propagate = require('propagate')
 const common = require('./common')
 const globalEmitter = require('./global_emitter')
@@ -333,14 +331,7 @@ class InterceptedRequestRouter {
       )
 
       if (allowUnmocked && req instanceof ClientRequest) {
-        const newReq =
-          options.proto === 'https'
-            ? originalHttpsRequest(options)
-            : originalHttpRequest(options)
-
-        propagate(newReq, req)
-        // We send the raw buffer as we received it, not as we interpreted it.
-        newReq.end(requestBodyBuffer)
+        req.emit('real-request')
       } else {
         const reqStr = common.stringifyRequest(options, requestBodyString)
         const err = new Error(`Nock: No match for request ${reqStr}`)

package/lib/interceptor.js

@@ -198,10 +198,16 @@ module.exports = class Interceptor {
     if (!fs) {
       throw new Error('No fs')
     }
-    const readStream = fs.createReadStream(filePath)
-    readStream.pause()
     this.filePath = filePath
-    return this.reply(statusCode, readStream, headers)
+    return this.reply(
+      statusCode,
+      () => {
+        const readStream = fs.createReadStream(filePath)
+        readStream.pause()
+        return readStream
+      },
+      headers,
+    )
   }
 
   // Also match request headers
@@ -446,15 +452,6 @@ module.exports = class Interceptor {
   markConsumed() {
     this.interceptionCounter++
 
-    if (
-      (this.scope.shouldPersist() || this.counter > 0) &&
-      this.interceptionCounter > 1 &&
-      this.filePath
-    ) {
-      this.body = fs.createReadStream(this.filePath)
-      this.body.pause()
-    }
-
     remove(this)
 
     if (!this.scope.shouldPersist() && this.counter < 1) {
@@ -503,7 +500,7 @@ module.exports = class Interceptor {
       strFormattingFn = common.percentDecode
     }
 
-    if (queries instanceof URLSearchParams) {
+    if (queries instanceof URLSearchParams || typeof queries === 'string') {
       // Normalize the data into the shape that is matched against.
       // Duplicate keys are handled by combining the values into an array.
       queries = querystring.parse(queries.toString())

package/lib/recorder.js

@@ -6,11 +6,21 @@ const { inspect } = require('util')
 
 const common = require('./common')
 const { restoreOverriddenClientRequest } = require('./intercept')
+const { BatchInterceptor } = require('@mswjs/interceptors')
+const { FetchInterceptor } = require('@mswjs/interceptors/fetch')
+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()],
+})
+
 function getScope(options) {
   const { proto, host, port } = common.normalizeRequestOptions(options)
   return common.normalizeOrigin(proto, host, port)
@@ -210,28 +220,33 @@ function record(recOptions) {
   //  we restore any requests that may have been overridden by other parts of nock (e.g. intercept)
   //  NOTE: This is hacky as hell but it keeps the backward compatibility *and* allows correct
   //    behavior in the face of other modules also overriding ClientRequest.
-  common.restoreOverriddenRequests()
+  // common.restoreOverriddenRequests()
   //  We restore ClientRequest as it messes with recording of modules that also override ClientRequest (e.g. xhr2)
   restoreOverriddenClientRequest()
 
   //  We override the requests so that we can save information on them before executing.
-  common.overrideRequests(function (proto, overriddenRequest, rawArgs) {
-    const { options, callback } = common.normalizeClientRequestArgs(...rawArgs)
-    const bodyChunks = []
+  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 overriddenRequest(options, callback)
+      return 
     }
     options._recording = true
 
-    const req = overriddenRequest(options, function (res) {
+    const req = new EventEmitter();
+    req.on('response', function () {
       debug(thisRecordingId, 'intercepting', proto, 'request to record')
 
-      //  We put our 'end' listener to the front of the listener array.
-      res.once('end', function () {
+      // 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
@@ -239,19 +254,26 @@ function record(recOptions) {
         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 = req.getHeaders()
+          reqheaders = Object.fromEntries(request.headers.entries())
           common.deleteHeadersField(reqheaders, 'user-agent')
         }
 
+        const headers = Object.fromEntries(response.headers.entries())
+        const res = {
+          statusCode: response.status,
+          headers,
+          rawHeaders: headers,
+        }
+
         const generateFn = outputObjects
           ? generateRequestAndResponseObject
           : generateRequestAndResponse
         let out = generateFn({
-          req,
-          bodyChunks,
+          req: options,
+          bodyChunks: [Buffer.from(await request.arrayBuffer())],
           options,
           res,
-          dataChunks,
+          dataChunks: [Buffer.from(await response.arrayBuffer())],
           reqheaders,
         })
 
@@ -284,33 +306,6 @@ function record(recOptions) {
         }
       })
 
-      let encoding
-      // We need to be aware of changes to the stream's encoding so that we
-      // don't accidentally mangle the data.
-      const { setEncoding } = res
-      res.setEncoding = function (newEncoding) {
-        encoding = newEncoding
-        return setEncoding.apply(this, arguments)
-      }
-
-      const dataChunks = []
-      // Replace res.push with our own implementation that stores chunks
-      const origResPush = res.push
-      res.push = function (data) {
-        if (data) {
-          if (encoding) {
-            data = Buffer.from(data, encoding)
-          }
-          dataChunks.push(data)
-        }
-
-        return origResPush.call(res, data)
-      }
-
-      if (callback) {
-        callback(res, options, callback)
-      }
-
       debug('finished setting up intercepting')
 
       // We override both the http and the https modules; when we are
@@ -322,45 +317,10 @@ function record(recOptions) {
       }
     })
 
-    const recordChunk = (chunk, encoding) => {
-      debug(thisRecordingId, 'new', proto, 'body chunk')
-      if (!Buffer.isBuffer(chunk)) {
-        chunk = Buffer.from(chunk, encoding)
-      }
-      bodyChunks.push(chunk)
-    }
-
-    const oldWrite = req.write
-    req.write = function (chunk, encoding) {
-      if (typeof chunk !== 'undefined') {
-        recordChunk(chunk, encoding)
-        oldWrite.apply(req, arguments)
-      } else {
-        throw new Error('Data was undefined.')
-      }
-    }
-
-    // Starting in Node 8, `OutgoingMessage.end()` directly calls an internal
-    // `write_` function instead of proxying to the public
-    // `OutgoingMessage.write()` method, so we have to wrap `end` too.
-    const oldEnd = req.end
-    req.end = function (chunk, encoding, callback) {
-      debug('req.end')
-      if (typeof chunk === 'function') {
-        callback = chunk
-        chunk = null
-      } else if (typeof encoding === 'function') {
-        callback = encoding
-        encoding = null
-      }
-
-      if (chunk) {
-        recordChunk(chunk, encoding)
-      }
-      oldEnd.call(req, chunk, encoding, callback)
-    }
-
-    return req
+    // 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')
   })
 }
 
@@ -371,7 +331,7 @@ function restore() {
     'restoring all the overridden http/https properties',
   )
 
-  common.restoreOverriddenRequests()
+  interceptor.dispose()
   restoreOverriddenClientRequest()
   recordingInProgress = false
 }

package/package.json

@@ -7,7 +7,7 @@
     "testing",
     "isolation"
   ],
-  "version": "14.0.0-beta.7",
+  "version": "14.0.0-beta.8",
   "author": "Pedro Teixeira <pedro.teixeira@gmail.com>",
   "repository": {
     "type": "git",
@@ -22,6 +22,7 @@
   "main": "./index.js",
   "types": "types",
   "dependencies": {
+    "@mswjs/interceptors": "^0.33.1",
     "json-stringify-safe": "^5.0.1",
     "propagate": "^2.0.0"
   },
@@ -44,7 +45,7 @@
     "mocha": "^9.1.3",
     "npm-run-all": "^4.1.5",
     "nyc": "^15.0.0",
-    "prettier": "3.1.0",
+    "prettier": "3.2.5",
     "proxyquire": "^2.1.0",
     "rimraf": "^3.0.0",
     "semantic-release": "^22.0.5",

package/types/index.d.ts

@@ -256,13 +256,13 @@ declare namespace nock {
     (
       fixtureName: string,
       options: BackOptions,
-      nockedFn: (nockDone: () => void) => void,
+      nockedFn: (nockDone: () => Promise<void>) => void,
     ): void
     (
       fixtureName: string,
       options?: BackOptions,
     ): Promise<{
-      nockDone: () => void
+      nockDone: () => Promise<void>
       context: BackContext
     }>
   }