@mswjs/interceptors 0.16.6 → 0.17.2

package/src/IsomorphicRequest.test.ts

@@ -0,0 +1,106 @@
+import { Headers } from 'headers-polyfill/lib'
+import { IsomorphicRequest } from './IsomorphicRequest'
+import { encodeBuffer } from './utils/bufferUtils'
+
+const url = new URL('http://dummy')
+const body = encodeBuffer(JSON.stringify({ hello: 'world' }))
+
+it('reads request body as json', async () => {
+  const request = new IsomorphicRequest(url, { body })
+
+  expect(request.bodyUsed).toBe(false)
+  expect(await request.json()).toEqual({ hello: 'world' })
+  expect(request.bodyUsed).toBe(true)
+  expect(() => request.json()).rejects.toThrow(
+    'Failed to execute "json" on "IsomorphicRequest": body buffer already read'
+  )
+})
+
+it('reads request body as text', async () => {
+  const request = new IsomorphicRequest(url, { body })
+
+  expect(request.bodyUsed).toBe(false)
+  expect(await request.text()).toEqual(JSON.stringify({ hello: 'world' }))
+  expect(request.bodyUsed).toBe(true)
+  expect(() => request.text()).rejects.toThrow(
+    'Failed to execute "text" on "IsomorphicRequest": body buffer already read'
+  )
+})
+
+it('reads request body as array buffer', async () => {
+  const request = new IsomorphicRequest(url, { body })
+
+  expect(request.bodyUsed).toBe(false)
+  expect(await request.arrayBuffer()).toEqual(encodeBuffer(`{"hello":"world"}`))
+  expect(request.bodyUsed).toBe(true)
+  expect(() => request.arrayBuffer()).rejects.toThrow(
+    'Failed to execute "arrayBuffer" on "IsomorphicRequest": body buffer already read'
+  )
+})
+
+it('returns default method', () => {
+  const request = new IsomorphicRequest(url, { body })
+  expect(request.method).toEqual('GET')
+})
+
+it('returns given method', () => {
+  const request = new IsomorphicRequest(url, { body, method: 'POST' })
+  expect(request.method).toEqual('POST')
+})
+
+it('returns given credentials', () => {
+  const request = new IsomorphicRequest(url, { body, credentials: 'include' })
+  expect(request.credentials).toEqual('include')
+})
+
+it('returns default credentials', () => {
+  const request = new IsomorphicRequest(url, { body })
+  expect(request.credentials).toEqual('same-origin')
+})
+
+it('returns empty headers if not provided', () => {
+  const request = new IsomorphicRequest(url, { body })
+  expect(request.headers).toEqual(new Headers())
+})
+
+it('returns given headers', () => {
+  const request = new IsomorphicRequest(url, {
+    body,
+    headers: { 'Content-Type': 'application/json' },
+  })
+  expect(request.headers).toEqual(
+    new Headers({ 'Content-Type': 'application/json' })
+  )
+})
+
+it('returns a copy of isomorphic request instance', () => {
+  const request = new IsomorphicRequest(url, {
+    body,
+    headers: { foo: 'bar' },
+  })
+  const derivedRequest = new IsomorphicRequest(request)
+
+  expect(request.id).toBe(derivedRequest.id)
+  expect(request.url.href).toBe(derivedRequest.url.href)
+  expect(request['_body']).toEqual(derivedRequest['_body'])
+  expect(request.headers).toEqual(derivedRequest.headers)
+  expect(request.method).toBe(derivedRequest.method)
+  expect(request.credentials).toBe(derivedRequest.credentials)
+  expect(request.bodyUsed).toBe(false)
+})
+
+it('clones current isomorphic request instance', () => {
+  const request = new IsomorphicRequest(url, {
+    body,
+    headers: { foo: 'bar' },
+  })
+  const clonedRequest = request.clone()
+
+  expect(clonedRequest.id).toBe(request.id)
+  expect(clonedRequest.method).toBe(request.method)
+  expect(clonedRequest.url.href).toBe(request.url.href)
+  expect(clonedRequest.headers).toEqual(request.headers)
+  expect(clonedRequest.credentials).toBe(request.credentials)
+  expect(clonedRequest['_body']).toEqual(request['_body'])
+  expect(clonedRequest.bodyUsed).toBe(false)
+})

package/src/IsomorphicRequest.ts

@@ -0,0 +1,86 @@
+import { Headers } from 'headers-polyfill/lib'
+import { invariant } from 'outvariant'
+import { decodeBuffer } from './utils/bufferUtils'
+import { uuidv4 } from './utils/uuid'
+
+export interface RequestInit {
+  method?: string
+  headers?: Record<string, string | string[]> | Headers
+  credentials?: RequestCredentials
+  body?: ArrayBuffer
+}
+
+export class IsomorphicRequest {
+  public id: string
+  public readonly url: URL
+  public readonly method: string
+  public readonly headers: Headers
+  public readonly credentials: RequestCredentials
+
+  private readonly _body: ArrayBuffer
+  private _bodyUsed: boolean
+
+  constructor(url: URL)
+  constructor(url: URL, init: RequestInit)
+  constructor(request: IsomorphicRequest)
+  constructor(input: IsomorphicRequest | URL, init: RequestInit = {}) {
+    const defaultBody = new ArrayBuffer(0)
+    this._bodyUsed = false
+
+    if (input instanceof IsomorphicRequest) {
+      this.id = input.id
+      this.url = input.url
+      this.method = input.method
+      this.headers = input.headers
+      this.credentials = input.credentials
+      this._body = input._body || defaultBody
+      return
+    }
+
+    this.id = uuidv4()
+    this.url = input
+    this.method = init.method || 'GET'
+    this.headers = new Headers(init.headers)
+    this.credentials = init.credentials || 'same-origin'
+    this._body = init.body || defaultBody
+  }
+
+  public get bodyUsed(): boolean {
+    return this._bodyUsed
+  }
+
+  public async text(): Promise<string> {
+    invariant(
+      !this.bodyUsed,
+      'Failed to execute "text" on "IsomorphicRequest": body buffer already read'
+    )
+
+    this._bodyUsed = true
+    return decodeBuffer(this._body)
+  }
+
+  public async json<T = any>(): Promise<T> {
+    invariant(
+      !this.bodyUsed,
+      'Failed to execute "json" on "IsomorphicRequest": body buffer already read'
+    )
+
+    this._bodyUsed = true
+    const text = decodeBuffer(this._body)
+    return JSON.parse(text)
+  }
+
+  public async arrayBuffer(): Promise<ArrayBuffer> {
+    invariant(
+      !this.bodyUsed,
+      'Failed to execute "arrayBuffer" on "IsomorphicRequest": body buffer already read'
+    )
+
+    this._bodyUsed = true
+    return this._body
+  }
+
+  public clone(): IsomorphicRequest {
+    return new IsomorphicRequest(this)
+  }
+}

package/src/RemoteHttpInterceptor.ts

@@ -1,16 +1,14 @@
 import { ChildProcess } from 'child_process'
 import { Headers } from 'headers-polyfill'
-import type {
-  HttpRequestEventMap,
-  InteractiveIsomorphicRequest,
-  IsomorphicRequest,
-} from './glossary'
+import { HttpRequestEventMap } from './glossary'
 import { Interceptor } from './Interceptor'
 import { BatchInterceptor } from './BatchInterceptor'
 import { ClientRequestInterceptor } from './interceptors/ClientRequest'
 import { XMLHttpRequestInterceptor } from './interceptors/XMLHttpRequest'
-import { createLazyCallback } from './utils/createLazyCallback'
 import { toIsoResponse } from './utils/toIsoResponse'
+import { IsomorphicRequest } from './IsomorphicRequest'
+import { bufferFrom } from './interceptors/XMLHttpRequest/utils/bufferFrom'
+import { InteractiveIsomorphicRequest } from './InteractiveIsomorphicRequest'
 
 export class RemoteHttpInterceptor extends BatchInterceptor<
   [ClientRequestInterceptor, XMLHttpRequestInterceptor]
@@ -59,7 +57,7 @@ export class RemoteHttpInterceptor extends BatchInterceptor<
         }
       })
 
-      // Listen for the mocked resopnse message from the parent.
+      // Listen for the mocked response message from the parent.
       this.log(
         'add "message" listener to the parent process',
         handleParentMessage
@@ -118,17 +116,19 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
         return
       }
 
-      const isomorphicRequest: IsomorphicRequest = JSON.parse(
-        serializedRequest,
-        requestReviver
-      )
+      const requestJson = JSON.parse(serializedRequest, requestReviver)
+      log('parsed intercepted request', requestJson)
 
-      log('parsed intercepted request', isomorphicRequest)
+      const body = bufferFrom(requestJson.body)
 
-      const interactiveIsomorphicRequest: InteractiveIsomorphicRequest = {
-        ...isomorphicRequest,
-        respondWith: createLazyCallback(),
-      }
+      const isomorphicRequest = new IsomorphicRequest(requestJson.url, {
+        ...requestJson,
+        body: body.buffer,
+      })
+
+      const interactiveIsomorphicRequest = new InteractiveIsomorphicRequest(
+        isomorphicRequest
+      )
 
       this.emitter.emit('request', interactiveIsomorphicRequest)
       await this.emitter.untilIdle('request', ({ args: [request] }) => {
@@ -143,14 +143,14 @@ export class RemoteHttpResolver extends Interceptor<HttpRequestEventMap> {
       const serializedResponse = JSON.stringify(mockedResponse)
 
       this.process.send(
-        `response:${isomorphicRequest.id}:${serializedResponse}`,
+        `response:${requestJson.id}:${serializedResponse}`,
         (error) => {
           if (error) {
             return
           }
 
           if (mockedResponse) {
-            // Emit an optimistinc "response" event at this point,
+            // Emit an optimistic "response" event at this point,
             // not to rely on the back-and-forth signaling for the sake of the event.
             this.emitter.emit(
               'response',

package/src/glossary.ts

@@ -1,28 +1,11 @@
 import type { HeadersObject, Headers } from 'headers-polyfill'
-import type { LazyCallback } from './utils/createLazyCallback'
+import type { InteractiveIsomorphicRequest } from './InteractiveIsomorphicRequest'
+import type { IsomorphicRequest } from './IsomorphicRequest'
 
 export const IS_PATCHED_MODULE: unique symbol = Symbol('isPatchedModule')
 
 export type RequestCredentials = 'omit' | 'include' | 'same-origin'
 
-export interface IsomorphicRequest {
-  id: string
-  url: URL
-  method: string
-  headers: Headers
-  /**
-   * The value of the request client's "credentials" option
-   * or a compatible alternative (i.e. `withCredentials` for `XMLHttpRequest`).
-   * Always equals to "omit" in Node.js.
-   */
-  credentials: RequestCredentials
-  body?: string
-}
-
-export interface InteractiveIsomorphicRequest extends IsomorphicRequest {
-  respondWith: LazyCallback<(mockedResponse: MockedResponse) => void>
-}
-
 export interface IsomorphicResponse {
   status: number
   statusText: string

package/src/index.ts

@@ -1,6 +1,9 @@
 export * from './glossary'
 export * from './Interceptor'
 export * from './BatchInterceptor'
+export * from './IsomorphicRequest'
+export * from './InteractiveIsomorphicRequest'
 
 /* Utils */
 export { getCleanUrl } from './utils/getCleanUrl'
+export { encodeBuffer, decodeBuffer } from './utils/bufferUtils'

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

@@ -139,10 +139,7 @@ test('emits the ENOTFOUND error connecting to a non-existing hostname given no m
   const emitter = new AsyncEventEmitter<HttpRequestEventMap>()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
-    {
-      emitter,
-      log,
-    }
+    { emitter, log }
   )
 
   request.on('error', (error: NodeJS.ErrnoException) => {
@@ -181,10 +178,7 @@ test('does not emit ENOTFOUND error connecting to an inactive server given mocke
   const handleError = jest.fn()
   const request = new NodeClientRequest(
     normalizeClientRequestArgs('http:', 'http://non-existing-url.com'),
-    {
-      emitter,
-      log,
-    }
+    { emitter, log }
   )
 
   emitter.on('request', async (request) => {

package/src/interceptors/ClientRequest/NodeClientRequest.ts

@@ -3,12 +3,7 @@ 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,
-} from '../../glossary'
-import { uuidv4 } from '../../utils/uuid'
+import { MockedResponse } from '../../glossary'
 import type { ClientRequestEmitter } from '.'
 import { concatChunkToBuffer } from './utils/concatChunkToBuffer'
 import {
@@ -21,12 +16,12 @@ import { getIncomingMessageBody } from './utils/getIncomingMessageBody'
 import { bodyBufferToString } from './utils/bodyBufferToString'
 import {
   ClientRequestWriteArgs,
-  ClientRequestWriteCallback,
   normalizeClientRequestWriteArgs,
 } from './utils/normalizeClientRequestWriteArgs'
 import { cloneIncomingMessage } from './utils/cloneIncomingMessage'
-import { createLazyCallback } from '../../utils/createLazyCallback'
-import { invariant } from 'outvariant'
+import { IsomorphicRequest } from '../../IsomorphicRequest'
+import { InteractiveIsomorphicRequest } from '../../InteractiveIsomorphicRequest'
+import { getArrayBuffer } from '../../utils/bufferUtils'
 
 export type Protocol = 'http' | 'https'
 
@@ -116,20 +111,9 @@ export class NodeClientRequest extends ClientRequest {
 
     const requestBody = this.getRequestBody(chunk)
     const isomorphicRequest = this.toIsomorphicRequest(requestBody)
-    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
-          )
-        },
-      }),
-    }
+    const interactiveIsomorphicRequest = new InteractiveIsomorphicRequest(
+      isomorphicRequest
+    )
 
     // Notify the interceptor about the request.
     // This will call any "request" listeners the users have.
@@ -377,7 +361,7 @@ export class NodeClientRequest extends ClientRequest {
     this.agent.destroy()
   }
 
-  private getRequestBody(chunk: ClientRequestEndChunk | null): string {
+  private getRequestBody(chunk: ClientRequestEndChunk | null): ArrayBuffer {
     const writtenRequestBody = bodyBufferToString(
       Buffer.concat(this.requestBody)
     )
@@ -388,16 +372,13 @@ export class NodeClientRequest extends ClientRequest {
       this.requestBody = concatChunkToBuffer(chunk, this.requestBody)
     }
 
-    const resolvedRequestBody = bodyBufferToString(
-      Buffer.concat(this.requestBody)
-    )
-
+    const resolvedRequestBody = Buffer.concat(this.requestBody)
     this.log('resolved request body:', resolvedRequestBody)
 
-    return resolvedRequestBody
+    return getArrayBuffer(resolvedRequestBody)
   }
 
-  private toIsomorphicRequest(body: string): IsomorphicRequest {
+  private toIsomorphicRequest(body: ArrayBuffer): IsomorphicRequest {
     this.log('creating isomorphic request object...')
 
     const outgoingHeaders = this.getHeaders()
@@ -412,14 +393,12 @@ export class NodeClientRequest extends ClientRequest {
       headers.set(headerName.toLowerCase(), headerValue.toString())
     }
 
-    const isomorphicRequest: IsomorphicRequest = {
-      id: uuidv4(),
-      url: this.url,
+    const isomorphicRequest = new IsomorphicRequest(this.url, {
+      body,
       method: this.options.method || 'GET',
       credentials: 'same-origin',
       headers,
-      body,
-    }
+    })
 
     this.log('successfully created isomorphic request!', isomorphicRequest)
     return isomorphicRequest

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

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

package/src/interceptors/XMLHttpRequest/XMLHttpRequestOverride.ts

@@ -11,14 +11,14 @@ import {
   headersToString,
 } from 'headers-polyfill'
 import { DOMParser } from '@xmldom/xmldom'
-import { InteractiveIsomorphicRequest, IsomorphicRequest } from '../../glossary'
 import { parseJson } from '../../utils/parseJson'
 import { toIsoResponse } from '../../utils/toIsoResponse'
-import { uuidv4 } from '../../utils/uuid'
 import { bufferFrom } from './utils/bufferFrom'
 import { createEvent } from './utils/createEvent'
 import type { XMLHttpRequestEmitter } from '.'
-import { createLazyCallback } from '../../utils/createLazyCallback'
+import { IsomorphicRequest } from '../../IsomorphicRequest'
+import { encodeBuffer } from '../../utils/bufferUtils'
+import { InteractiveIsomorphicRequest } from '../../InteractiveIsomorphicRequest'
 
 type XMLHttpRequestEventHandler = (
   this: XMLHttpRequest,
@@ -84,7 +84,6 @@ export const createXMLHttpRequestOverride = (
     public statusText: string
     public user?: string
     public password?: string
-    public data: string
     public async?: boolean
     public response: any
     public responseText: string
@@ -132,7 +131,6 @@ export const createXMLHttpRequestOverride = (
       this.withCredentials = false
       this.status = 200
       this.statusText = 'OK'
-      this.data = ''
       this.response = ''
       this.responseType = 'text'
       this.responseText = ''
@@ -154,7 +152,7 @@ export const createXMLHttpRequestOverride = (
       this.readyState = nextState
 
       if (nextState !== this.UNSENT) {
-        this.log('triggerring readystate change...')
+        this.log('triggering readystate change...')
         this.trigger('readystatechange')
       }
     }
@@ -195,7 +193,6 @@ export const createXMLHttpRequestOverride = (
       this.setReadyState(this.UNSENT)
       this.status = 200
       this.statusText = 'OK'
-      this.data = ''
       this.response = null as any
       this.responseText = null as any
       this.responseXML = null as any
@@ -229,10 +226,14 @@ export const createXMLHttpRequestOverride = (
       }
     }
 
-    public send(data?: string) {
+    public send(data?: string | ArrayBuffer) {
       this.log('send %s %s', this.method, this.url)
-
-      this.data = data || ''
+      let buffer: ArrayBuffer
+      if (typeof data === 'string') {
+        buffer = encodeBuffer(data)
+      } else {
+        buffer = data || new ArrayBuffer(0)
+      }
 
       let url: URL
 
@@ -248,19 +249,16 @@ export const createXMLHttpRequestOverride = (
       this.log('request headers', this._requestHeaders)
 
       // Create an intercepted request instance exposed to the request intercepting middleware.
-      const isomorphicRequest: IsomorphicRequest = {
-        id: uuidv4(),
-        url,
+      const isomorphicRequest = new IsomorphicRequest(url, {
+        body: buffer,
         method: this.method,
         headers: this._requestHeaders,
         credentials: this.withCredentials ? 'include' : 'omit',
-        body: this.data,
-      }
+      })
 
-      const interactiveIsomorphicRequest: InteractiveIsomorphicRequest = {
-        ...isomorphicRequest,
-        respondWith: createLazyCallback(),
-      }
+      const interactiveIsomorphicRequest = new InteractiveIsomorphicRequest(
+        isomorphicRequest
+      )
 
       this.log(
         'emitting the "request" event for %d listener(s)...',
@@ -331,8 +329,8 @@ export const createXMLHttpRequestOverride = (
           if (mockedResponse.body && this.response) {
             this.setReadyState(this.LOADING)
 
-            // Presense of the mocked response implies a response body (not null).
-            // Presense of the coerced `this.response` implies the mocked body is valid.
+            // Presence of the mocked response implies a response body (not null).
+            // Presence of the coerced `this.response` implies the mocked body is valid.
             const bodyBuffer = bufferFrom(mockedResponse.body)
 
             // Trigger a progress event based on the mocked response body.
@@ -428,8 +426,8 @@ export const createXMLHttpRequestOverride = (
             originalRequest.timeout = this.timeout
           }
 
-          this.log('send', this.data)
-          originalRequest.send(this.data)
+          this.log('send', data)
+          originalRequest.send(data)
         }
       })
     }

package/src/interceptors/XMLHttpRequest/index.ts

@@ -1,9 +1,6 @@
 import { invariant } from 'outvariant'
-import {
-  HttpRequestEventMap,
-  InteractiveIsomorphicRequest,
-  IS_PATCHED_MODULE,
-} from '../../glossary'
+import { HttpRequestEventMap, IS_PATCHED_MODULE } from '../../glossary'
+import { InteractiveIsomorphicRequest } from '../../InteractiveIsomorphicRequest'
 import { Interceptor } from '../../Interceptor'
 import { AsyncEventEmitter } from '../../utils/AsyncEventEmitter'
 import { createXMLHttpRequestOverride } from './XMLHttpRequestOverride'