@mswjs/interceptors 0.15.3 → 0.16.0

package/src/interceptors/ClientRequest/NodeClientRequest.test.ts

@@ -1,36 +1,35 @@
 /**
  * @jest-environment node
  */
-import { EventEmitter } from 'events'
+import { debug } from 'debug'
 import * as express from 'express'
-import { ServerApi, createServer } from '@open-draft/test-server'
+import { HttpServer } from '@open-draft/test-server/http'
 import { NodeClientRequest } from './NodeClientRequest'
 import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
 import { normalizeClientRequestArgs } from './utils/normalizeClientRequestArgs'
+import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
+import { sleep } from '../../../test/helpers'
+import { HttpRequestEventMap } from '../../glossary'
 
 interface ErrorConnectionRefused extends NodeJS.ErrnoException {
   address: string
   port: number
 }
 
-let httpServer: ServerApi
+const httpServer = new HttpServer((app) => {
+  app.post('/comment', (_req, res) => {
+    res.status(200).send('original-response')
+  })
 
-function waitFor(duration: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, duration)
+  app.post('/write', express.text(), (req, res) => {
+    res.status(200).send(req.body)
   })
-}
+})
 
-beforeAll(async () => {
-  httpServer = await createServer((app) => {
-    app.post('/comment', (_req, res) => {
-      res.status(200).send('original-response')
-    })
+const log = debug('test')
 
-    app.post('/write', express.text(), (req, res) => {
-      res.status(200).send(req.body)
-    })
-  })
+beforeAll(async () => {
+  await httpServer.listen()
 })
 
 afterAll(async () => {
@@ -38,24 +37,27 @@ afterAll(async () => {
 })
 
 test('gracefully finishes the request when it has a mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://any.thing', {
       method: 'PUT',
     }),
     {
-      observer: new EventEmitter(),
-      resolver() {
-        return {
-          status: 301,
-          headers: {
-            'x-custom-header': 'yes',
-          },
-          body: 'mocked-response',
-        }
-      },
+      emitter,
+      log,
     }
   )
 
+  emitter.on('request', (request) => {
+    request.respondWith({
+      status: 301,
+      headers: {
+        'x-custom-header': 'yes',
+      },
+      body: 'mocked-response',
+    })
+  })
+
   request.on('response', async (response) => {
     // Request must be marked as finished.
     expect(request.finished).toEqual(true)
@@ -76,20 +78,22 @@ test('gracefully finishes the request when it has a mocked response', (done) =>
 })
 
 test('responds with a mocked response when requesting an existing hostname', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
-    normalizeClientRequestArgs('http:', httpServer.http.makeUrl('/comment')),
+    normalizeClientRequestArgs('http:', httpServer.http.url('/comment')),
     {
-      observer: new EventEmitter(),
-      async resolver() {
-        await waitFor(250)
-        return {
-          status: 201,
-          body: 'mocked-response',
-        }
-      },
+      emitter,
+      log,
     }
   )
 
+  emitter.on('request', (request) => {
+    request.respondWith({
+      status: 201,
+      body: 'mocked-response',
+    })
+  })
+
   request.on('response', async (response) => {
     expect(response.statusCode).toEqual(201)
 
@@ -103,13 +107,14 @@ test('responds with a mocked response when requesting an existing hostname', (do
 })
 
 test('performs the request as-is given resolver returned no mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
-    normalizeClientRequestArgs('http:', httpServer.http.makeUrl('/comment'), {
+    normalizeClientRequestArgs('http:', httpServer.http.url('/comment'), {
       method: 'POST',
     }),
     {
-      observer: new EventEmitter(),
-      resolver() {},
+      emitter,
+      log,
     }
   )
 
@@ -131,11 +136,12 @@ test('performs the request as-is given resolver returned no mocked response', (d
 })
 
 test('emits the ENOTFOUND error connecting to a non-existing hostname given no mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
     {
-      observer: new EventEmitter(),
-      resolver() {},
+      emitter,
+      log,
     }
   )
 
@@ -149,11 +155,12 @@ test('emits the ENOTFOUND error connecting to a non-existing hostname given no m
 })
 
 test('emits the ECONNREFUSED error connecting to an inactive server given no mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://localhost:12345'),
     {
-      observer: new EventEmitter(),
-      resolver() {},
+      emitter,
+      log,
     }
   )
 
@@ -170,21 +177,24 @@ test('emits the ECONNREFUSED error connecting to an inactive server given no moc
 })
 
 test('does not emit ENOTFOUND error connecting to an inactive server given mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const handleError = jest.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
     {
-      observer: new EventEmitter(),
-      async resolver() {
-        await waitFor(250)
-        return {
-          status: 200,
-          statusText: 'Works',
-        }
-      },
+      emitter,
+      log,
     }
   )
 
+  emitter.on('request', async (request) => {
+    await sleep(250)
+    request.respondWith({
+      status: 200,
+      statusText: 'Works',
+    })
+  })
+
   request.on('error', handleError)
   request.on('response', (response) => {
     expect(handleError).not.toHaveBeenCalled()
@@ -196,21 +206,24 @@ test('does not emit ENOTFOUND error connecting to an inactive server given mocke
 })
 
 test('does not emit ECONNREFUSED error connecting to an inactive server given mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const handleError = jest.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://localhost:9876'),
     {
-      observer: new EventEmitter(),
-      async resolver() {
-        await waitFor(250)
-        return {
-          status: 200,
-          statusText: 'Works',
-        }
-      },
+      emitter,
+      log,
     }
   )
 
+  emitter.on('request', async (request) => {
+    await sleep(250)
+    request.respondWith({
+      status: 200,
+      statusText: 'Works',
+    })
+  })
+
   request.on('error', handleError)
   request.on('response', (response) => {
     expect(handleError).not.toHaveBeenCalled()
@@ -222,16 +235,17 @@ test('does not emit ECONNREFUSED error connecting to an inactive server given mo
 })
 
 test('sends the request body to the server given no mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
-    normalizeClientRequestArgs('http:', httpServer.http.makeUrl('/write'), {
+    normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',
       headers: {
         'Content-Type': 'text/plain',
       },
     }),
     {
-      observer: new EventEmitter(),
-      resolver() {},
+      emitter,
+      log,
     }
   )
 
@@ -251,22 +265,25 @@ test('sends the request body to the server given no mocked response', (done) =>
 })
 
 test('does not send request body to the original server given mocked response', (done) => {
+  const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
-    normalizeClientRequestArgs('http:', httpServer.http.makeUrl('/write'), {
+    normalizeClientRequestArgs('http:', httpServer.http.url('/write'), {
       method: 'POST',
     }),
     {
-      observer: new EventEmitter(),
-      async resolver() {
-        await waitFor(200)
-        return {
-          status: 301,
-          body: 'mock created!',
-        }
-      },
+      emitter,
+      log,
     }
   )
 
+  emitter.on('request', async (request) => {
+    await sleep(200)
+    request.respondWith({
+      status: 301,
+      body: 'mock created!',
+    })
+  })
+
   request.write('one')
   request.write('two')
 

package/src/interceptors/ClientRequest/NodeClientRequest.ts

@@ -1,15 +1,15 @@
-import { Debugger, debug } from 'debug'
+import type { Debugger } from 'debug'
 import type { RequestOptions } from 'http'
 import { ClientRequest, IncomingMessage } from 'http'
 import { until } from '@open-draft/until'
 import { Headers, objectToHeaders } from 'headers-polyfill/lib'
 import type {
+  InteractiveIsomorphicRequest,
   IsomorphicRequest,
   MockedResponse,
-  Observer,
-  Resolver,
-} from '../../createInterceptor'
+} from '../../glossary'
 import { uuidv4 } from '../../utils/uuid'
+import type { ClientRequestEmitter } from '.'
 import { concatChunkToBuffer } from './utils/concatChunkToBuffer'
 import {
   ClientRequestEndChunk,
@@ -25,12 +25,14 @@ import {
   normalizeClientRequestWriteArgs,
 } from './utils/normalizeClientRequestWriteArgs'
 import { cloneIncomingMessage } from './utils/cloneIncomingMessage'
+import { createLazyCallback } from '../../utils/createLazyCallback'
+import { invariant } from 'outvariant'
 
 export type Protocol = 'http' | 'https'
 
 export interface NodeClientOptions {
-  observer: Observer
-  resolver: Resolver
+  emitter: ClientRequestEmitter
+  log: Debugger
 }
 
 export class NodeClientRequest extends ClientRequest {
@@ -38,13 +40,17 @@ export class NodeClientRequest extends ClientRequest {
    * The list of internal Node.js errors to suppress while
    * using the "mock" response source.
    */
-  static suppressErrorCodes = ['ENOTFOUND', 'ECONNREFUSED', 'ECONNRESET']
+  static suppressErrorCodes = [
+    'ENOTFOUND',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EAI_AGAIN',
+  ]
 
   private url: URL
   private options: RequestOptions
   private response: IncomingMessage
-  private resolver: Resolver
-  private observer: Observer
+  private emitter: ClientRequestEmitter
   private log: Debugger
   private chunks: Array<{
     chunk?: string | Buffer
@@ -62,7 +68,9 @@ export class NodeClientRequest extends ClientRequest {
   ) {
     super(requestOptions, callback)
 
-    this.log = debug(`http ${requestOptions.method} ${url.href}`)
+    this.log = options.log.extend(
+      `request ${requestOptions.method} ${url.href}`
+    )
 
     this.log('constructing ClientRequest using options:', {
       url,
@@ -72,8 +80,7 @@ export class NodeClientRequest extends ClientRequest {
 
     this.url = url
     this.options = requestOptions
-    this.resolver = options.resolver
-    this.observer = options.observer
+    this.emitter = options.emitter
 
     // Construct a mocked response message.
     this.response = new IncomingMessage(this.socket!)
@@ -96,9 +103,14 @@ export class NodeClientRequest extends ClientRequest {
         }
 
         /**
-         * @todo Do not call callback if the `chunk` is empty.
+         * Prevent invoking the callback if the written chunk is empty.
          * @see https://nodejs.org/api/http.html#requestwritechunk-encoding-callback
          */
+        if (!chunk || chunk.length === 0) {
+          this.log('written chunk is empty, skipping callback...')
+          return
+        }
+
         this.log('executing custom write callback:', callback)
         callback?.(error)
       },
@@ -121,110 +133,137 @@ export class NodeClientRequest extends ClientRequest {
 
     const requestBody = this.getRequestBody(chunk)
     const isomorphicRequest = this.toIsomorphicRequest(requestBody)
-    this.observer.emit('request', isomorphicRequest)
+    const interactiveIsomorphicRequest: InteractiveIsomorphicRequest = {
+      ...isomorphicRequest,
+      respondWith: createLazyCallback({
+        maxCalls: 1,
+        maxCallsCallback() {
+          invariant(
+            false,
+            'Failed to respond to "%s %s" request: the "request" event has already been responded to.',
+            isomorphicRequest.method,
+            isomorphicRequest.url.href
+          )
+        },
+      }),
+    }
 
-    this.log('executing response resolver...')
+    // Notify the interceptor about the request.
+    // This will call any "request" listeners the users have.
+    this.log(
+      'emitting the "request" event for %d listener(s)...',
+      this.emitter.listenerCount('request')
+    )
+    this.emitter.emit('request', interactiveIsomorphicRequest)
 
     // Execute the resolver Promise like a side-effect.
     // Node.js 16 forces "ClientRequest.end" to be synchronous and return "this".
-    until(async () => this.resolver(isomorphicRequest, this.response)).then(
-      ([resolverException, mockedResponse]) => {
-        this.log('resolver has finished')
-
-        // Halt the request whenever the resolver throws an exception.
-        if (resolverException) {
-          this.log(
-            'encountered resolver exception, aborting request...',
-            resolverException
-          )
-          this.emit('error', resolverException)
-          this.terminate()
-
-          return this
-        }
+    until(async () => {
+      await this.emitter.untilIdle('request')
+      this.log('all request listeners have been resolved!')
+
+      const [mockedResponse] =
+        await interactiveIsomorphicRequest.respondWith.invoked()
+      this.log('event.respondWith called with:', mockedResponse)
+
+      return mockedResponse
+    }).then(([resolverException, mockedResponse]) => {
+      this.log('the listeners promise awaited!')
+
+      // Halt the request whenever the resolver throws an exception.
+      if (resolverException) {
+        this.log(
+          'encountered resolver exception, aborting request...',
+          resolverException
+        )
+        this.emit('error', resolverException)
+        this.terminate()
 
-        if (mockedResponse) {
-          this.log('received mocked response:', mockedResponse)
-          this.responseSource = 'mock'
-
-          const isomorphicResponse = toIsoResponse(mockedResponse)
-          this.respondWith(mockedResponse)
-          this.log(
-            isomorphicResponse.status,
-            isomorphicResponse.statusText,
-            isomorphicResponse.body,
-            '(MOCKED)'
-          )
+        return this
+      }
 
-          callback?.()
+      if (mockedResponse) {
+        this.log('received mocked response:', mockedResponse)
+        this.responseSource = 'mock'
+
+        const isomorphicResponse = toIsoResponse(mockedResponse)
+        this.respondWith(mockedResponse)
+        this.log(
+          isomorphicResponse.status,
+          isomorphicResponse.statusText,
+          isomorphicResponse.body,
+          '(MOCKED)'
+        )
 
-          this.log('emitting the custom "response" event...')
-          this.observer.emit('response', isomorphicRequest, isomorphicResponse)
+        callback?.()
 
-          return this
-        }
+        this.log('emitting the custom "response" event...')
 
-        this.log('no mocked response found!')
+        this.emitter.emit('response', isomorphicRequest, isomorphicResponse)
 
-        // Set the response source to "bypass".
-        // Any errors emitted past this point are not suppressed.
-        this.responseSource = 'bypass'
+        return this
+      }
 
-        // Propagate previously captured errors.
-        // For example, a ECONNREFUSED error when connecting to a non-existing host.
-        if (this.capturedError) {
-          this.emit('error', this.capturedError)
-          return this
-        }
+      this.log('no mocked response received!')
 
-        // Write the request body chunks in the order of ".write()" calls.
-        // Note that no request body has been written prior to this point
-        // in order to prevent the Socket to communicate with a potentially
-        // existing server.
-        this.log('writing request chunks...', this.chunks)
+      // Set the response source to "bypass".
+      // Any errors emitted past this point are not suppressed.
+      this.responseSource = 'bypass'
 
-        for (const { chunk, encoding, callback } of this.chunks) {
-          encoding
-            ? super.write(chunk, encoding, callback)
-            : super.write(chunk, callback)
-        }
+      // Propagate previously captured errors.
+      // For example, a ECONNREFUSED error when connecting to a non-existing host.
+      if (this.capturedError) {
+        this.emit('error', this.capturedError)
+        return this
+      }
 
-        this.once('error', (error) => {
-          this.log('original request error:', error)
-        })
+      // Write the request body chunks in the order of ".write()" calls.
+      // Note that no request body has been written prior to this point
+      // in order to prevent the Socket to communicate with a potentially
+      // existing server.
+      this.log('writing request chunks...', this.chunks)
 
-        this.once('abort', () => {
-          this.log('original request aborted!')
-        })
+      for (const { chunk, encoding, callback } of this.chunks) {
+        encoding
+          ? super.write(chunk, encoding, callback)
+          : super.write(chunk, callback)
+      }
 
-        this.once('response-internal', async (response: IncomingMessage) => {
-          const responseBody = await getIncomingMessageBody(response)
-          this.log(response.statusCode, response.statusMessage, responseBody)
-          this.log('original response headers:', response.headers)
-
-          this.log('emitting the custom "response" event...')
-          this.observer.emit('response', isomorphicRequest, {
-            status: response.statusCode || 200,
-            statusText: response.statusMessage || 'OK',
-            headers: objectToHeaders(response.headers),
-            body: responseBody,
-          })
+      this.once('error', (error) => {
+        this.log('original request error:', error)
+      })
+
+      this.once('abort', () => {
+        this.log('original request aborted!')
+      })
+
+      this.once('response-internal', async (response: IncomingMessage) => {
+        const responseBody = await getIncomingMessageBody(response)
+        this.log(response.statusCode, response.statusMessage, responseBody)
+        this.log('original response headers:', response.headers)
+
+        this.log('emitting the custom "response" event...')
+        this.emitter.emit('response', isomorphicRequest, {
+          status: response.statusCode || 200,
+          statusText: response.statusMessage || 'OK',
+          headers: objectToHeaders(response.headers),
+          body: responseBody,
         })
-
-        this.log('performing original request...')
-
-        return super.end(
-          ...[
-            chunk,
-            encoding as any,
-            () => {
-              this.log('original request end!')
-              callback?.()
-            },
-          ].filter(Boolean)
-        )
-      }
-    )
+      })
+
+      this.log('performing original request...')
+
+      return super.end(
+        ...[
+          chunk,
+          encoding as any,
+          () => {
+            this.log('original request end!')
+            callback?.()
+          },
+        ].filter(Boolean)
+      )
+    })
 
     return this
   }

package/src/interceptors/ClientRequest/http.get.ts

@@ -1,25 +1,21 @@
 import { ClientRequest } from 'node:http'
-import { Observer, Resolver } from '../../createInterceptor'
-import { NodeClientRequest, Protocol } from './NodeClientRequest'
+import {
+  NodeClientOptions,
+  NodeClientRequest,
+  Protocol,
+} from './NodeClientRequest'
 import {
   ClientRequestArgs,
   normalizeClientRequestArgs,
 } from './utils/normalizeClientRequestArgs'
 
-export function get(
-  protocol: Protocol,
-  resolver: Resolver,
-  observer: Observer
-) {
+export function get(protocol: Protocol, options: NodeClientOptions) {
   return (...args: ClientRequestArgs): ClientRequest => {
     const clientRequestArgs = normalizeClientRequestArgs(
       `${protocol}:`,
       ...args
     )
-    const request = new NodeClientRequest(clientRequestArgs, {
-      resolver,
-      observer,
-    })
+    const request = new NodeClientRequest(clientRequestArgs, options)
 
     /**
      * @note https://nodejs.org/api/http.html#httpgetoptions-callback

package/src/interceptors/ClientRequest/http.request.ts

@@ -1,19 +1,18 @@
 import { debug } from 'debug'
 import { ClientRequest } from 'http'
-import { Observer, Resolver } from '../../createInterceptor'
-import { NodeClientRequest, Protocol } from './NodeClientRequest'
+import {
+  NodeClientOptions,
+  NodeClientRequest,
+  Protocol,
+} from './NodeClientRequest'
 import {
   normalizeClientRequestArgs,
   ClientRequestArgs,
 } from './utils/normalizeClientRequestArgs'
 
-const log = debug('http.request')
+const log = debug('http request')
 
-export function request(
-  protocol: Protocol,
-  resolver: Resolver,
-  observer: Observer
-) {
+export function request(protocol: Protocol, options: NodeClientOptions) {
   return (...args: ClientRequestArgs): ClientRequest => {
     log('request call (protocol "%s"):', protocol, args)
 
@@ -21,9 +20,6 @@ export function request(
       `${protocol}:`,
       ...args
     )
-    return new NodeClientRequest(clientRequestArgs, {
-      observer,
-      resolver,
-    })
+    return new NodeClientRequest(clientRequestArgs, options)
   }
 }