nock 15.0.0 → 15.0.1

package/{lib → dist/lib}/interceptor.js

@@ -1,26 +1,132 @@
-'use strict'
-
-const fs = require('node:fs')
-const stringify = require('json-stringify-safe')
-const querystring = require('node:querystring')
-const { URL, URLSearchParams } = require('node:url')
-
-const common = require('./common')
-const { remove } = require('./intercept')
-const matchBody = require('./match_body')
-
-module.exports = class Interceptor {
-  /**
-   *
-   * Valid argument types for `uri`:
-   *  - A string used for strict comparisons with pathname.
-   *    The search portion of the URI may also be postfixed, in which case the search params
-   *    are striped and added via the `query` method.
-   *  - A RegExp instance that tests against only the pathname of requests.
-   *  - A synchronous function bound to this Interceptor instance. It's provided the pathname
-   *    of requests and must return a boolean denoting if the request is considered a match.
-   */
-  constructor(scope, uri, method, requestBody, interceptorOptions) {
+                                         
+                                                
+
+                         
+           
+          
+          
+        
+             
+          
+                    
+                  
+                                                         
+                                                           
+
+                                
+          
+          
+          
+                    
+                  
+                            
+
+                                  
+          
+          
+                                            
+
+                                               
+                                                  
+
+                                   
+               
+                         
+                                                   
+                                                                      
+                          
+                                    
+                                 
+                      
+
+                               
+                           
+                         
+                                    
+                                                  
+
+import fs from 'node:fs'
+import querystring from 'node:querystring'
+import { URL, URLSearchParams } from 'node:url'
+
+import stringify from './stringify.js'
+import * as common from './common.js'
+import { remove } from './intercept.js'
+import matchBody from './match_body.js'
+
+class Interceptor {
+  /** @internal */
+                      
+  /** @internal */
+                                                                 
+  /** @internal */
+                        
+  /** @internal */
+                                                            
+  /** @internal */
+                      
+  /** @internal */
+                                   
+  /** @internal */
+                                                             
+  /** @internal */
+                  
+          
+             
+                                                     
+                         
+  /** @internal */
+                                                
+  /** @internal */
+                         
+  /** @internal */
+                                                      
+  /** @internal */
+                                         
+  /** @internal */
+                              
+  /** @internal */
+                               
+  /** @internal */
+                           
+  /** @internal */
+                                
+  /** @internal */
+                                                  
+  /** @internal */
+                                             
+  /** @internal */
+                                         
+  /** @internal */
+                                                              
+  /** @internal */
+                                              
+  /** @internal */
+                                     
+  /** @internal */
+                                               
+  /** @internal */
+                                                  
+  /** @internal */
+                           
+  /** @internal */
+                   
+  /** @internal */
+                           
+  /** @internal */
+                                      
+  /** @internal */
+                                
+  /** @internal */
+                            
+
+  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
     // When enabled filteringScope ignores the passed URL entirely so we skip validation.
@@ -29,8 +135,8 @@ module.exports = class Interceptor {
       uriIsStr &&
       !scope.scopeOptions.filteringScope &&
       !scope.basePathname &&
-      !uri.startsWith('/') &&
-      !uri.startsWith('*')
+      !(uri          ).startsWith('/') &&
+      !(uri          ).startsWith('*')
     ) {
       throw Error(
         `Non-wildcard URL path strings must begin with a slash (otherwise they won't match anything) (got: ${uri})`,
@@ -70,9 +176,20 @@ module.exports = class Interceptor {
     this.delayBodyInMs = 0
 
     this.optional = false
+    this.isPassthrough = false
+
+    this.__nock_filteredScope = undefined
+    this.__nock_scopeKey = undefined
+    this.__nock_scope = undefined
+    this.__nock_scopeOptions = undefined
+    this.__nock_scopeHost = undefined
+    this.interceptionCounter = 0
+    this.statusCode = undefined
+    this.headers = undefined
+    this.rawHeaders = []
 
     // strip off literal query parameters if they were provided as part of the URI
-    if (uriIsStr && uri.includes('?')) {
+    if (uriIsStr && (uri          ).includes('?')) {
       // localhost is a dummy value because the URL constructor errors for only relative inputs
       const parsedURL = new URL(this.path, 'http://localhost')
       this.path = parsedURL.pathname
@@ -92,7 +209,19 @@ module.exports = class Interceptor {
     return this
   }
 
-  replyWithError(errorMessage) {
+  passthrough() {
+    this.isPassthrough = true
+
+    this.options = {
+      ...this.scope.scopeOptions,
+      ...this.options,
+    }
+
+    this.scope.add(this._key, this)
+    return this.scope
+  }
+
+  replyWithError(errorMessage                                      ) {
     this.errorMessage = errorMessage
 
     this.options = {
@@ -104,7 +233,7 @@ module.exports = class Interceptor {
     return this.scope
   }
 
-  reply(statusCode, body, rawHeaders) {
+  reply(statusCode     , body      , rawHeaders               ) {
     // support the format of only passing in a callback
     if (typeof statusCode === 'function') {
       if (arguments.length > 1) {
@@ -163,10 +292,20 @@ module.exports = class Interceptor {
         throw new Error('Error encoding response body into JSON')
       }
 
-      if (!this.headers['content-type']) {
+      if (!this.headers ['content-type']) {
         // https://tools.ietf.org/html/rfc7231#section-3.1.1.5
         this.rawHeaders.push('Content-Type', 'application/json')
       }
+
+      // Fix content-length header if it exists and doesn't match the stringified body
+      const contentLengthIndex = this.rawHeaders.findIndex(
+        (value     , index        ) =>
+          index % 2 === 0 && value.toLowerCase() === 'content-length',
+      )
+      if (contentLengthIndex !== -1) {
+        const actualLength = Buffer.byteLength(body, 'utf8')
+        this.rawHeaders[contentLengthIndex + 1] = String(actualLength)
+      }
     }
 
     if (this.scope.contentLen) {
@@ -187,7 +326,7 @@ module.exports = class Interceptor {
     return this.scope
   }
 
-  replyWithFile(statusCode, filePath, headers) {
+  replyWithFile(statusCode        , filePath        , headers               ) {
     if (!fs) {
       throw new Error('No fs')
     }
@@ -203,7 +342,11 @@ module.exports = class Interceptor {
     )
   }
 
-  reqheaderMatches(expected, actual, key) {
+  reqheaderMatches(
+    expected                      ,
+    actual               ,
+    key        ,
+  ) {
     if (expected !== undefined && actual !== undefined) {
       if (typeof expected === 'function') {
         return expected(actual)
@@ -221,17 +364,12 @@ module.exports = class Interceptor {
     return false
   }
 
-  /**
-   * @param {Request} request
-   * @param {string} body - string or hex
-   * @returns {string[]}
-   */
-  match(request, body) {
+  match(request         , body        ) {
     const url = new URL(request.url)
     // TODO: fix request log to string
     this.scope.logger('attempting match %j, body = %j', request, body)
 
-    const mismatches = []
+    const mismatches           = []
     let path = url.pathname + url.search
     let matchKey
 
@@ -245,7 +383,13 @@ module.exports = class Interceptor {
       path = this.scope.transformPathFunction(path)
     }
 
-    const requestMatchesFilter = ({ name, value: predicate }) => {
+    const requestMatchesFilter = ({
+      name,
+      value: predicate,
+    }   
+                  
+                
+     ) => {
       const headerValue = request.headers.get(name)
       if (typeof predicate === 'function') {
         return predicate(headerValue)
@@ -265,7 +409,7 @@ module.exports = class Interceptor {
       }
     }
 
-    const reqHeadersMatch = Object.keys(this.reqheaders).every(key =>
+    const reqHeadersMatch = Object.keys(this.reqheaders).every((key        ) =>
       this.reqheaderMatches(
         this.reqheaders[key],
         request.headers.get(key),
@@ -288,7 +432,7 @@ module.exports = class Interceptor {
       mismatches.push(msg)
     }
 
-    const badHeaders = this.badheaders.filter(header =>
+    const badHeaders = this.badheaders.filter((header        ) =>
       request.headers.has(header),
     )
 
@@ -303,7 +447,7 @@ module.exports = class Interceptor {
       this.scope.logger('query matching skipped')
     } else {
       // can't rely on pathname or search being in the options, but path has a default
-      const [pathname, search] = path.split('?')
+      const [pathname, search] = (path          ).split('?')
       const matchQueries = this.matchQuery({ search })
 
       if (!matchQueries) {
@@ -322,12 +466,14 @@ module.exports = class Interceptor {
     // necessarily match and we have to remove the scope that was matched (vs.
     // that was defined).
     if (this.__nock_filteredScope) {
-      matchKey = this.__nock_filteredScope
+      matchKey = this.__nock_filteredScope          
     } else {
       matchKey = common.normalizeOrigin(url)
     }
 
-    if (!common.matchStringOrRegexp(matchKey, this.basePath)) {
+    if (
+      !common.matchStringOrRegexp(matchKey, this.basePath                   )
+    ) {
       const msg = `Base path mismatch: expected ${this.basePath}, got ${matchKey}`
       this.scope.logger(msg)
       mismatches.push(msg)
@@ -339,7 +485,9 @@ module.exports = class Interceptor {
         this.scope.logger(msg)
         mismatches.push(msg)
       }
-    } else if (!common.matchStringOrRegexp(path, this.path)) {
+    } else if (
+      !common.matchStringOrRegexp(path, this.path                   )
+    ) {
       const msg = `Path mismatch: expected ${this.path}, got ${path}`
       this.scope.logger(msg)
       mismatches.push(msg)
@@ -360,13 +508,7 @@ module.exports = class Interceptor {
     return mismatches
   }
 
-  /**
-   * Return true when the interceptor's method, protocol, host, port, and path
-   * match the provided options.
-   *
-   * @param {Request} request
-   */
-  matchOrigin(request) {
+  matchOrigin(request         ) {
     const url = new URL(request.url)
     const isPathFn = typeof this.path === 'function'
     const isRegex = this.path instanceof RegExp
@@ -384,28 +526,29 @@ module.exports = class Interceptor {
     if (this.scope.transformPathFunction) {
       path = this.scope.transformPathFunction(path)
     }
-    const comparisonKey = isPathFn || isRegex ? this.__nock_scopeKey : this._key
+    const comparisonKey =
+      isPathFn || isRegex ? (this.__nock_scopeKey          ) : this._key
     const matchKey = `${method} ${url.protocol}//${url.hostname}:${port}${path}`
 
     if (isPathFn) {
-      return !!(matchKey.match(comparisonKey) && this.path(path))
+      return !!(matchKey.match(comparisonKey) && (this.path            )(path))
     }
 
     if (isRegex && !isRegexBasePath) {
-      return !!matchKey.match(comparisonKey) && this.path.test(path)
+      return !!matchKey.match(comparisonKey) && (this.path          ).test(path)
     }
 
     if (isRegexBasePath) {
-      return this.scope.basePath.test(matchKey) && !!path.match(this.path)
+      return (
+        (this.scope.basePath          ).test(matchKey) &&
+        !!path.match(this.path          )
+      )
     }
 
     return comparisonKey === matchKey
   }
 
-  /**
-   * @param {string} hostname
-   */
-  matchHostName(hostname) {
+  matchHostName(hostname        ) {
     const { basePath } = this.scope
 
     if (basePath instanceof RegExp) {
@@ -415,7 +558,7 @@ module.exports = class Interceptor {
     return hostname === this.scope.urlParts.hostname
   }
 
-  matchQuery(options) {
+  matchQuery(options                     ) {
     if (this.queries === true) {
       return true
     }
@@ -431,8 +574,8 @@ module.exports = class Interceptor {
     return common.dataEqual(this.queries, reqQueries)
   }
 
-  filteringPath(...args) {
-    this.scope.filteringPath(...args)
+  filteringPath(...args       ) {
+    ;(this.scope.filteringPath            ).apply(this.scope, args)
     return this
   }
 
@@ -440,7 +583,7 @@ module.exports = class Interceptor {
   // by request body?
 
   markConsumed() {
-    this.interceptionCounter++
+    this.interceptionCounter = (this.interceptionCounter || 0) + 1
 
     remove(this)
 
@@ -449,27 +592,25 @@ module.exports = class Interceptor {
     }
   }
 
-  matchHeader(name, value) {
+  matchHeader(name        , value                      ) {
     this.interceptorMatchHeaders.push({ name, value })
     return this
   }
 
-  basicAuth({ user, pass = '' }) {
+  basicAuth({ user, pass = '' }                                 ) {
     const encoded = Buffer.from(`${user}:${pass}`).toString('base64')
     this.matchHeader('authorization', `Basic ${encoded}`)
     return this
   }
 
-  /**
-   * Set query strings for the interceptor
-   * @name query
-   * @param queries Object of query string name,values (accepts regexp values)
-   * @public
-   * @example
-   * // Will match 'http://zombo.com/?q=t'
-   * nock('http://zombo.com').get('/').query({q: 't'});
-   */
-  query(queries) {
+  query(
+    queries 
+               
+              
+                       
+                           
+                                                       ,
+  ) {
     if (this.queries !== null) {
       throw Error(`Query parameters have already been defined`)
     }
@@ -498,26 +639,17 @@ module.exports = class Interceptor {
       throw Error(`Argument Error: ${queries}`)
     }
 
-    this.queries = {}
+    this.queries = {}                       
     for (const [key, value] of Object.entries(queries)) {
       const formatted = common.formatQueryValue(key, value, strFormattingFn)
       const [formattedKey, formattedValue] = formatted
-      this.queries[formattedKey] = formattedValue
+      ;(this.queries                       )[formattedKey] = formattedValue
     }
 
     return this
   }
 
-  /**
-   * Set number of times will repeat the interceptor
-   * @name times
-   * @param newCounter Number of times to repeat (should be > 0)
-   * @public
-   * @example
-   * // Will repeat mock 5 times for same king of request
-   * nock('http://zombo.com).get('/').times(5).reply(200, 'Ok');
-   */
-  times(newCounter) {
+  times(newCounter        ) {
     if (newCounter < 1) {
       return this
     }
@@ -527,49 +659,19 @@ module.exports = class Interceptor {
     return this
   }
 
-  /**
-   * An sugar syntax for times(1)
-   * @name once
-   * @see {@link times}
-   * @public
-   * @example
-   * nock('http://zombo.com).get('/').once().reply(200, 'Ok');
-   */
   once() {
     return this.times(1)
   }
 
-  /**
-   * An sugar syntax for times(2)
-   * @name twice
-   * @see {@link times}
-   * @public
-   * @example
-   * nock('http://zombo.com).get('/').twice().reply(200, 'Ok');
-   */
   twice() {
     return this.times(2)
   }
 
-  /**
-   * An sugar syntax for times(3).
-   * @name thrice
-   * @see {@link times}
-   * @public
-   * @example
-   * nock('http://zombo.com).get('/').thrice().reply(200, 'Ok');
-   */
   thrice() {
     return this.times(3)
   }
 
-  /**
-   * Delay the response by a certain number of ms.
-   *
-   * @param {number} ms - Number of milliseconds to wait before response is sent
-   * @return {Interceptor} - the current interceptor for chaining
-   */
-  delay(ms) {
+  delay(ms        ) {
     if (typeof ms === 'number') {
       this.delayBodyInMs = ms
       return this
@@ -578,3 +680,5 @@ module.exports = class Interceptor {
     }
   }
 }
+
+export { Interceptor }

package/dist/lib/interceptors/builtin.d.ts

@@ -0,0 +1,3 @@
+declare function activate(): void;
+declare function deactivate(): void;
+export { activate, deactivate };

package/dist/lib/interceptors/builtin.js

@@ -0,0 +1,56 @@
+import * as common from '../common.js'
+import handleRequest from '../handle-request.js'
+import { setGetRequestBody } from '../utils/node/index.js'
+import { BatchInterceptor } from '@mswjs/interceptors'
+import { FetchInterceptor } from '@mswjs/interceptors/fetch'
+import { HttpRequestInterceptor } from '@mswjs/interceptors/http'
+
+const interceptor = new BatchInterceptor({
+  name: 'intercept',
+  interceptors: [new HttpRequestInterceptor(), new FetchInterceptor()],
+})
+
+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, initiator }) {
+      if (request.headers.get('expect') === '100-continue') {
+        // We currently do not support mocking 100-continue responses, so they are passed through for now.
+        return
+      }
+
+      // 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(
+        await request.clone().arrayBuffer(),
+        request.headers.get('content-encoding') || '',
+      )               
+
+      const decompressedRequest = new Request(request, {
+        body:
+          requestBodyBuffer.byteLength > 0 && request.method !== 'GET'
+            ? requestBodyBuffer
+            : undefined,
+      })
+      if (requestBodyBuffer.byteLength > 0 && request.method === 'GET') {
+        setGetRequestBody(decompressedRequest, requestBodyBuffer)
+      }
+
+      const response = await handleRequest(decompressedRequest)
+      if (response) {
+        controller.respondWith(response)
+      }
+    },
+  )
+}
+
+function deactivate() {
+  interceptor.dispose()
+}
+
+export { activate, deactivate }

package/dist/lib/match_body.d.ts

@@ -0,0 +1 @@
+export default function matchBody(request: Request, spec: any, body: string): any;