@depup/msw 2.15.0-depup.9 → 3.0.1-depup.0

package/src/core/experimental/define-network.test.ts

@@ -1,8 +1,9 @@
+import { HttpHandler, HttpMethods } from '#http/http-handler'
 import { NetworkSource } from './sources/network-source'
 import { defineNetwork } from './define-network'
 
 describe('enable()', () => {
-  it('throws if called on already enabled network', () => {
+  test('throws if called on already enabled network', () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
     }
@@ -19,7 +20,7 @@ describe('enable()', () => {
     expect(network.enable()).toBeUndefined()
   })
 
-  it('returns a sync enable if all the sources are sync', () => {
+  test('returns a sync enable if all the sources are sync', () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
     }
@@ -30,7 +31,7 @@ describe('enable()', () => {
     expect(network.enable()).toBeUndefined()
   })
 
-  it('returns an async enable if any of the sources are async', () => {
+  test('returns an async enable if any of the sources are async', () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
     }
@@ -45,7 +46,7 @@ describe('enable()', () => {
     expect(network.enable()).toBeInstanceOf(Promise)
   })
 
-  it('returns an async enable if all the sources are async', () => {
+  test('returns an async enable if all the sources are async', () => {
     class AsyncNetworkSource extends NetworkSource {
       enable = async () => {}
     }
@@ -59,7 +60,7 @@ describe('enable()', () => {
 })
 
 describe('disable()', () => {
-  it('throws if called on already enabled network', () => {
+  test('throws if called on already enabled network', () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
     }
@@ -77,7 +78,7 @@ describe('disable()', () => {
     expect(network.disable()).toBeUndefined()
   })
 
-  it('returns a sync disable if all the sources are sync', () => {
+  test('returns a sync disable if all the sources are sync', () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
       disable = () => {}
@@ -90,7 +91,7 @@ describe('disable()', () => {
     expect(network.disable()).toBeUndefined()
   })
 
-  it('returns an async disable if any of the sources are async', async () => {
+  test('returns an async disable if any of the sources are async', async () => {
     class SyncNetworkSource extends NetworkSource {
       enable = () => {}
       disable = () => {}
@@ -108,7 +109,7 @@ describe('disable()', () => {
     expect(network.disable()).toBeInstanceOf(Promise)
   })
 
-  it('returns an async disable if all the sources are async', async () => {
+  test('returns an async disable if all the sources are async', async () => {
     class AsyncNetworkSource extends NetworkSource {
       enable = async () => {}
       disable = async () => {}
@@ -121,4 +122,38 @@ describe('disable()', () => {
     await network.enable()
     expect(network.disable()).toBeInstanceOf(Promise)
   })
+
+  test('observes both the handler and the source disposal rejections', async () => {
+    const unhandledRejectionListener = vi.fn()
+    process.on('unhandledRejection', unhandledRejectionListener)
+
+    try {
+      class RejectingNetworkSource extends NetworkSource {
+        enable = () => {}
+        disable = () => Promise.reject(new Error('Source disposal error'))
+      }
+
+      const handler = new HttpHandler(HttpMethods.GET, '/resource', () => {})
+      handler.dispose = () =>
+        Promise.reject(new Error('Handler disposal error'))
+
+      const network = defineNetwork({
+        sources: [new RejectingNetworkSource()],
+        handlers: [handler],
+      })
+
+      network.enable()
+
+      await expect(network.disable()).rejects.toThrow()
+
+      // Give an unobserved rejection a chance to surface.
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      expect(unhandledRejectionListener).not.toHaveBeenCalled()
+    } finally {
+      // Detach the listener whether the assertions above pass or not,
+      // so a failure here cannot leak it into the rest of the run.
+      process.off('unhandledRejection', unhandledRejectionListener)
+    }
+  })
 })

package/src/core/experimental/define-network.ts

@@ -4,21 +4,16 @@ import {
   NetworkSource,
   type ExtractSourceEvents,
 } from './sources/network-source'
-import { type NetworkFrameResolutionContext } from './frames/network-frame'
-import { type UnhandledFrameHandle } from './on-unhandled-frame'
+import type { NetworkFrameResolutionContext } from './frames/network-frame'
+import type { UnhandledFrameHandle } from './on-unhandled-frame'
 import {
   HandlersController,
   InMemoryHandlersController,
   type AnyHandler,
 } from './handlers-controller'
-import { toReadonlyArray } from '../utils/internal/toReadonlyArray'
-import { Disposable } from '../utils/internal/Disposable'
-
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I,
-) => void
-  ? I
-  : never
+import { toReadonlyArray } from '../utils/internal/to-readonly-array'
+import { Disposable } from '../utils/internal/disposable'
+import type { UnionToIntersection } from '../type-utils'
 
 type MergeEventMaps<Sources extends Array<NetworkSource<any>>> =
   UnionToIntersection<ExtractSourceEvents<Sources[number]>> extends infer R
@@ -69,7 +64,7 @@ export interface NetworkApi<
   events: Emitter<MergeEventMaps<Sources>>
 }
 
-export interface NetworkHandlersApi {
+interface NetworkHandlersApi {
   use: (...handlers: Array<AnyHandler>) => void
   resetHandlers: (...handlers: Array<AnyHandler>) => void
   restoreHandlers: () => void
@@ -222,10 +217,34 @@ export function defineNetwork<Sources extends Array<NetworkSource<any>>>(
       )
 
       readyState = NetworkReadyState.DISABLED
+
+      // Let the handlers release the resources they hold before
+      // tearing down the network itself. Handlers may still need the
+      // network while disposing of themselves (e.g. to close the
+      // connections they own).
+      const handlersDisposal = handlersController.dispose()
       disposable.dispose()
 
-      return colorlessPromiseAll(
+      /**
+       * @note Tear down the sources synchronously, never behind the
+       * handlers disposal. `disable()` is not always awaited (e.g.
+       * `server.close()` is synchronous), and a deferred teardown would
+       * race any `enable()` that follows, disabling the sources that the
+       * new session has just enabled.
+       */
+      const sourcesDisposal = colorlessPromiseAll(
         resolvedOptions.sources.map((source) => source.disable()),
+      )
+
+      /**
+       * @note Await both disposals so neither rejection goes unobserved.
+       * Chaining them would leave the source disposal floating whenever
+       * the handlers disposal rejects.
+       */
+      return (
+        handlersDisposal instanceof Promise
+          ? Promise.all([handlersDisposal, sourcesDisposal]).then(() => {})
+          : sourcesDisposal
       ) as MaybePromise<ReturnType<Sources[number]['disable']>>
     },
     use(...handlers) {
@@ -238,7 +257,7 @@ export function defineNetwork<Sources extends Array<NetworkSource<any>>>(
       handlersController.restore()
     },
     listHandlers() {
-      return toReadonlyArray(handlersController.currentHandlers())
+      return toReadonlyArray(handlersController.listHandlers())
     },
   }
 }

package/src/core/experimental/frames/http-frame.test.ts

@@ -1,11 +1,14 @@
-import { http } from '../../http'
-import { graphql } from '../../graphql'
-import { ws } from '../../ws'
-import { bypass } from '../../bypass'
+import { FetchRequest } from '@mswjs/interceptors'
+import { http } from '#http/http'
+import { graphql } from '../../../graphql'
+import { ws } from '../../../ws'
+import { bypass } from '#utils/bypass'
 import type { HttpNetworkFrameEventMap } from './http-frame'
 import { HttpNetworkFrame } from './http-frame'
 import { InMemoryHandlersController } from '../../experimental/handlers-controller'
-import { getSiblingHandlers } from '../../utils/internal/attachSiblingHandlers'
+import { getSiblingHandlers } from '../../utils/internal/attach-sibling-handlers'
+
+const gql = graphql.link('*')
 
 beforeAll(() => {
   vi.spyOn(console, 'error').mockImplementation(() => {})
@@ -31,7 +34,7 @@ function spyOnNetworkFrame(frame: HttpNetworkFrame) {
   }
 }
 
-it('filters only request type handlers', async () => {
+test('filters only request type handlers', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -43,7 +46,7 @@ it('filters only request type handlers', async () => {
   })
 
   const httpHandlers = [http.post('http://localhost/api/user', () => {})]
-  const graphqlHandlers = [graphql.query('GetUser', () => {})]
+  const graphqlHandlers = [gql.query('GetUser', () => {})]
   const webSocketHandlers = [
     ws.link('ws://localhost').addEventListener('connection', () => {}),
   ]
@@ -65,7 +68,7 @@ it('filters only request type handlers', async () => {
   expect(frame.getHandlers(new InMemoryHandlersController([]))).toEqual([])
 })
 
-it('resolves a matching request', async () => {
+test('resolves a matching request', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -116,7 +119,7 @@ it('resolves a matching request', async () => {
   ])
 })
 
-it('resolves a non-matching request', async () => {
+test('resolves a non-matching request', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -167,7 +170,55 @@ it('resolves a non-matching request', async () => {
   ])
 })
 
-it('resolves a matched passthrough', async () => {
+/**
+ * @todo Revisit the `http.all()` handler below once `http.connect()`
+ * is supported: a matching CONNECT handler must take precedence.
+ */
+test('passes through an unhandled CONNECT request without applying the unhandled frame strategy', async () => {
+  class HttpFrame extends HttpNetworkFrame {
+    respondWith = vi.fn()
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const frame = new HttpFrame({
+    request: new FetchRequest('http://localhost/127.0.0.1:443', {
+      method: 'CONNECT',
+    }),
+  })
+  const { events } = spyOnNetworkFrame(frame)
+  const unhandledFrameCallback = vi.fn()
+
+  const matches = await frame.resolve(
+    [
+      http.all('*', () => {
+        return new Response(null, { status: 204 })
+      }),
+    ],
+    unhandledFrameCallback,
+    { quiet: true },
+  )
+
+  expect.soft(matches).toBe(null)
+  expect.soft(frame.passthrough).toHaveBeenCalledOnce()
+  expect.soft(frame.respondWith).not.toHaveBeenCalled()
+  expect.soft(frame.errorWith).not.toHaveBeenCalled()
+  expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
+  expect.soft(events).toEqual([
+    expect.objectContaining({
+      type: 'request:start',
+      requestId: frame.data.id,
+      request: frame.data.request,
+    }),
+    expect.objectContaining({
+      type: 'request:end',
+      requestId: frame.data.id,
+      request: frame.data.request,
+    }),
+  ])
+})
+
+test('resolves a matched passthrough', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -214,7 +265,7 @@ it('resolves a matched passthrough', async () => {
   ])
 })
 
-it('resolves a bypassed request', async () => {
+test('resolves a bypassed request', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -256,7 +307,7 @@ it('resolves a bypassed request', async () => {
   ])
 })
 
-it('errors the request on unhandled exception', async () => {
+test('errors the request on unhandled exception', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()
@@ -309,7 +360,7 @@ it('errors the request on unhandled exception', async () => {
     )
 })
 
-it('does not print an unhandled exception if the "unhandledException" listener is present', async () => {
+test('does not print an unhandled exception if the "unhandledException" listener is present', async () => {
   class HttpFrame extends HttpNetworkFrame {
     respondWith = vi.fn()
     passthrough = vi.fn()

package/src/core/experimental/frames/http-frame.ts

@@ -5,25 +5,27 @@ import {
   NetworkFrame,
   type NetworkFrameResolutionContext,
 } from './network-frame'
-import { toPublicUrl } from '../../utils/request/toPublicUrl'
-import { executeHandlers } from '../../utils/executeHandlers'
-import { storeResponseCookies } from '../../utils/request/storeResponseCookies'
-import { isPassthroughResponse, shouldBypassRequest } from '../request-utils'
-import { devUtils } from '../../utils/internal/devUtils'
+import { toPublicUrl } from '../../utils/request/to-public-url'
+import { isStringEqual } from '../../utils/internal/is-string-equal'
+import { executeHandlers } from '../../utils/execute-handlers'
+import { storeResponseCookies } from '../../utils/request/store-response-cookies'
+import { shouldBypassRequest } from '../request-utils'
+import { isPassthroughResponse } from '#utils/passthrough'
+import { devUtils } from '../../utils/internal/dev-utils'
 import {
   executeUnhandledFrameHandle,
   type UnhandledFrameHandle,
 } from '../on-unhandled-frame'
 import type { HandlersController } from '../handlers-controller'
-import { type AnyHandler } from '../handlers-controller'
-import { type RequestHandler } from '../../handlers/RequestHandler'
+import type { AnyHandler } from '../handlers-controller'
+import type { RequestHandler } from '../../handlers/request-handler'
 
 interface HttpNetworkFrameOptions {
   id?: string
   request: Request
 }
 
-export class RequestEvent<
+class RequestEvent<
   DataType extends { requestId: string; request: Request } = {
     requestId: string
     request: Request
@@ -66,7 +68,7 @@ export class ResponseEvent<
   }
 }
 
-export class UnhandledExceptionEvent<
+class UnhandledExceptionEvent<
   DataType extends {
     error: Error
     requestId: string
@@ -190,6 +192,24 @@ export abstract class HttpNetworkFrame extends NetworkFrame<
 
     // No matching handlers.
     if (lookupResult == null) {
+      /**
+       * @note Unhandled CONNECT requests establish a tunnel through a proxy.
+       * They are transport, not the request the developer cares about, so
+       * they pass through silently regardless of the unhandled frame strategy.
+       * The request sent through the tunnel gets its own resolution.
+       */
+      if (isStringEqual(request.method, 'CONNECT')) {
+        this.events.emit(
+          new RequestEvent('request:end', {
+            requestId,
+            request,
+          }),
+        )
+
+        this.passthrough()
+        return null
+      }
+
       this.events.emit(
         new RequestEvent('request:unhandled', {
           requestId,

package/src/core/experimental/frames/websocket-frame.test.ts

@@ -1,11 +1,14 @@
-import { http } from '../../http'
-import { graphql } from '../../graphql'
-import { ws } from '../../ws'
+import { CloseEvent } from '@mswjs/interceptors/WebSocket'
+import { http } from '#http/http'
+import { graphql } from '../../../graphql'
+import { ws } from '../../../ws'
 import type { WebSocketNetworkFrameEventMap } from './websocket-frame'
 import { WebSocketNetworkFrame } from './websocket-frame'
 import { createTestWebSocketConnection } from '../../../../test/support/ws-test-utils'
 import { InMemoryHandlersController } from '#core/experimental/handlers-controller'
 
+const gql = graphql.link('*')
+
 beforeAll(() => {
   vi.spyOn(console, 'error').mockImplementation(() => {})
 })
@@ -30,7 +33,7 @@ function spyOnWebSocketFrame(frame: WebSocketNetworkFrame) {
   }
 }
 
-it('filters only websocket type handlers', async () => {
+test('filters only websocket type handlers', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -40,7 +43,7 @@ it('filters only websocket type handlers', async () => {
   const frame = new WebSocketFrame({ connection })
 
   const httpHandlers = [http.post('http://localhost/api/user', () => {})]
-  const graphqlHandlers = [graphql.query('GetUser', () => {})]
+  const graphqlHandlers = [gql.query('GetUser', () => {})]
   const webSocketHandlers = [
     ws.link('ws://localhost').addEventListener('connection', () => {}),
   ]
@@ -55,7 +58,7 @@ it('filters only websocket type handlers', async () => {
   expect(frame.getHandlers(new InMemoryHandlersController([]))).toEqual([])
 })
 
-it('resolves a matching connection', async () => {
+test('resolves a matching connection', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -84,14 +87,14 @@ it('resolves a matching connection', async () => {
   expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
   expect.soft(events).toEqual([
     expect.objectContaining({
-      type: 'connection',
+      type: 'websocket:connection',
       url: connection.client.url,
       protocols: connection.info.protocols,
     }),
   ])
 })
 
-it('resolves a connection when there are no handlers', async () => {
+test('resolves a connection when there are no handlers', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -119,14 +122,14 @@ it('resolves a connection when there are no handlers', async () => {
   )
   expect.soft(events).toEqual([
     expect.objectContaining({
-      type: 'connection',
+      type: 'websocket:connection',
       url: connection.client.url,
       protocols: connection.info.protocols,
     }),
   ])
 })
 
-it('resolves a non-matching connection', async () => {
+test('resolves a non-matching connection', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -157,14 +160,14 @@ it('resolves a non-matching connection', async () => {
   )
   expect.soft(events).toEqual([
     expect.objectContaining({
-      type: 'connection',
+      type: 'websocket:connection',
       url: connection.client.url,
       protocols: connection.info.protocols,
     }),
   ])
 })
 
-it('returns null and prints the error on unhandled exception', async () => {
+test('returns null and prints the error on unhandled exception', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -197,7 +200,7 @@ it('returns null and prints the error on unhandled exception', async () => {
   expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
   expect.soft(events).toEqual([
     expect.objectContaining({
-      type: 'connection',
+      type: 'websocket:connection',
       url: connection.client.url,
       protocols: connection.info.protocols,
     }),
@@ -219,7 +222,7 @@ it('returns null and prints the error on unhandled exception', async () => {
     )
 })
 
-it('does not print an unhandled exception if the "unhandledException" listener is present', async () => {
+test('does not print an unhandled exception if the "unhandledException" listener is present', async () => {
   class WebSocketFrame extends WebSocketNetworkFrame {
     passthrough = vi.fn()
     errorWith = vi.fn()
@@ -255,7 +258,7 @@ it('does not print an unhandled exception if the "unhandledException" listener i
   expect.soft(unhandledFrameCallback).not.toHaveBeenCalled()
   expect.soft(events).toEqual([
     expect.objectContaining({
-      type: 'connection',
+      type: 'websocket:connection',
       url: connection.client.url,
       protocols: connection.info.protocols,
     }),
@@ -276,3 +279,114 @@ it('does not print an unhandled exception if the "unhandledException" listener i
   )
   expect.soft(console.error).not.toHaveBeenCalled()
 })
+
+test('emits "websocket:error" when the client connection errors', async () => {
+  class WebSocketFrame extends WebSocketNetworkFrame {
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const connection = createTestWebSocketConnection('ws://localhost/api')
+  const frame = new WebSocketFrame({ connection })
+  const { events } = spyOnWebSocketFrame(frame)
+
+  const api = ws.link('ws://localhost/api')
+  await frame.resolve([api.addEventListener('connection', () => {})], vi.fn(), {
+    quiet: true,
+  })
+
+  connection.client.socket.dispatchEvent(new Event('error'))
+
+  expect(events).toEqual([
+    expect.objectContaining({
+      type: 'websocket:connection',
+    }),
+    expect.objectContaining({
+      type: 'websocket:error',
+      url: connection.client.url,
+      protocols: connection.info.protocols,
+      error: undefined,
+    }),
+  ])
+})
+
+test('exposes the "error" property of the error event on "websocket:error"', async () => {
+  class WebSocketFrame extends WebSocketNetworkFrame {
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const connection = createTestWebSocketConnection('ws://localhost/api')
+  const frame = new WebSocketFrame({ connection })
+  const { events } = spyOnWebSocketFrame(frame)
+
+  const api = ws.link('ws://localhost/api')
+  await frame.resolve([api.addEventListener('connection', () => {})], vi.fn(), {
+    quiet: true,
+  })
+
+  const error = new Error('Connection failed')
+  connection.client.socket.dispatchEvent(
+    Object.assign(new Event('error'), { error }),
+  )
+
+  expect(events[1]).toEqual(
+    expect.objectContaining({
+      type: 'websocket:error',
+      error,
+    }),
+  )
+})
+
+test('exposes the "cause" property of the error event on "websocket:error"', async () => {
+  class WebSocketFrame extends WebSocketNetworkFrame {
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const connection = createTestWebSocketConnection('ws://localhost/api')
+  const frame = new WebSocketFrame({ connection })
+  const { events } = spyOnWebSocketFrame(frame)
+
+  const api = ws.link('ws://localhost/api')
+  await frame.resolve([api.addEventListener('connection', () => {})], vi.fn(), {
+    quiet: true,
+  })
+
+  const cause = new Error('Connection failed')
+  connection.client.socket.dispatchEvent(
+    Object.assign(new Event('error'), { cause }),
+  )
+
+  expect(events[1]).toEqual(
+    expect.objectContaining({
+      type: 'websocket:error',
+      error: cause,
+    }),
+  )
+})
+
+test('stops emitting "websocket:error" once the client connection closes', async () => {
+  class WebSocketFrame extends WebSocketNetworkFrame {
+    passthrough = vi.fn()
+    errorWith = vi.fn()
+  }
+
+  const connection = createTestWebSocketConnection('ws://localhost/api')
+  const frame = new WebSocketFrame({ connection })
+  const { events } = spyOnWebSocketFrame(frame)
+
+  const api = ws.link('ws://localhost/api')
+  await frame.resolve([api.addEventListener('connection', () => {})], vi.fn(), {
+    quiet: true,
+  })
+
+  connection.client.socket.dispatchEvent(new CloseEvent('close'))
+  connection.client.socket.dispatchEvent(new Event('error'))
+
+  expect(events).toEqual([
+    expect.objectContaining({
+      type: 'websocket:connection',
+    }),
+  ])
+})