@mswjs/interceptors 0.14.1 → 0.15.2

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)
   }
 }

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

@@ -0,0 +1,43 @@
+import * as http from 'http'
+import { HttpServer } from '@open-draft/test-server/http'
+import { ClientRequestInterceptor } from '.'
+
+const httpServer = new HttpServer((app) => {
+  app.get('/', (_req, res) => {
+    res.status(200).send('/')
+  })
+  app.get('/get', (_req, res) => {
+    res.status(200).send('/get')
+  })
+})
+
+const interceptor = new ClientRequestInterceptor()
+
+beforeAll(async () => {
+  await httpServer.listen()
+
+  interceptor.apply()
+})
+
+afterAll(async () => {
+  interceptor.dispose()
+  await httpServer.close()
+})
+
+it('forbids calling "respondWith" multiple times for the same request', (done) => {
+  const requestUrl = httpServer.http.url('/')
+
+  interceptor.on('request', (request) => {
+    request.respondWith({ status: 200 })
+  })
+
+  interceptor.on('request', (request) => {
+    expect(() => request.respondWith({ status: 301 })).toThrow(
+      `Failed to respond to "GET ${requestUrl}" request: the "request" event has already been responded to.`
+    )
+
+    done()
+  })
+
+  http.get(requestUrl)
+})

package/src/interceptors/ClientRequest/index.ts

@@ -1,61 +1,61 @@
-import { debug } from 'debug'
 import http from 'http'
 import https from 'https'
-import { Interceptor } from '../../createInterceptor'
+import { HttpRequestEventMap } from '../../glossary'
+import { Interceptor } from '../../Interceptor'
+import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { get } from './http.get'
-import { Protocol } from './NodeClientRequest'
 import { request } from './http.request'
+import { NodeClientOptions, Protocol } from './NodeClientRequest'
 
-const log = debug('http override')
+export type ClientRequestEmitter = AsyncEventEmitter<HttpRequestEventMap>
 
-export type RequestModule = typeof http | typeof https
-type PureModules = Map<
-  Protocol,
-  {
-    module: RequestModule
-    get: typeof http.get
-    request: typeof http.request
-  }
->
+export type ClientRequestModules = Map<Protocol, typeof http | typeof https>
 
 /**
- * Intercepts requests issued by native "http" and "https" modules.
+ * Intercept requests made via the `ClientRequest` class.
+ * Such requests include `http.get`, `https.request`, etc.
  */
-export const interceptClientRequest: Interceptor = (observer, resolver) => {
-  const pureModules: PureModules = new Map()
-  const modules: [Protocol, RequestModule][] = [
-    ['http', http],
-    ['https', https],
-  ]
-
-  for (const [protocol, requestModule] of modules) {
-    log('patching the "%s" module...', protocol)
-
-    pureModules.set(protocol, {
-      module: requestModule,
-      request: requestModule.request,
-      get: requestModule.get,
-    })
-
-    // @ts-ignore Call signature overloads are incompatible.
-    requestModule.request =
-      // Force a line-break to prevent ignoring the "request" call.
-      request(protocol, resolver, observer)
-
-    // @ts-ignore Call signature overloads are incompatible.
-    requestModule.get =
-      // Force a line-break to prevent ignoring the "get" call.
-      get(protocol, resolver, observer)
+export class ClientRequestInterceptor extends Interceptor<HttpRequestEventMap> {
+  static symbol = Symbol('http')
+  private modules: ClientRequestModules
+
+  constructor() {
+    super(ClientRequestInterceptor.symbol)
+
+    this.modules = new Map()
+    this.modules.set('http', http)
+    this.modules.set('https', https)
   }
 
-  return () => {
-    log('done, restoring modules...')
+  protected setup(): void {
+    const log = this.log.extend('setup')
 
-    for (const requestModule of pureModules.values()) {
-      requestModule.module.get = requestModule.get
-      requestModule.module.request = requestModule.request
-    }
+    for (const [protocol, requestModule] of this.modules) {
+      const { request: pureRequest, get: pureGet } = requestModule
+
+      this.subscriptions.push(() => {
+        requestModule.request = pureRequest
+        requestModule.get = pureGet
 
-    pureModules.clear()
+        log('native "%s" module restored!', protocol)
+      })
+
+      const options: NodeClientOptions = {
+        emitter: this.emitter,
+        log: this.log,
+      }
+
+      // @ts-ignore
+      requestModule.request =
+        // Force a line break.
+        request(protocol, options)
+
+      // @ts-ignore
+      requestModule.get =
+        // Force a line break.
+        get(protocol, options)
+
+      log('native "%s" module patched!', protocol)
+    }
   }
 }

package/src/interceptors/ClientRequest/utils/getIncomingMessageBody.test.ts

@@ -42,3 +42,12 @@ test('returns utf8 string given a gzipped response body with incorrect "content-
 
   expect(await pendingResponseBody).toEqual('three')
 })
+
+test('returns empty string given an empty body', async () => {
+  const message = new IncomingMessage(new Socket())
+
+  const pendingResponseBody = getIncomingMessageBody(message)
+  message.emit('end')
+
+  expect(await pendingResponseBody).toEqual('')
+})

package/src/interceptors/ClientRequest/utils/getIncomingMessageBody.ts

@@ -25,9 +25,16 @@ export function getIncomingMessageBody(
     stream.setEncoding(encoding)
     log('using encoding:', encoding)
 
-    stream.once('data', (responseBody) => {
+    let body = '';
+
+    stream.on('data', (responseBody) => {
       log('response body read:', responseBody)
-      resolve(responseBody)
+      body += responseBody;
+    })
+
+    stream.once('end', () => {
+      log('response body end');
+      resolve(body);
     })
 
     stream.once('error', (error) => {