msw 2.3.0-ws.rc-5 → 2.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "msw",
-  "version": "2.3.0-ws.rc-5",
+  "version": "2.3.0",
   "description": "Seamless REST/GraphQL API mocking library for browser and Node.js.",
   "main": "./lib/core/index.js",
   "module": "./lib/core/index.mjs",
@@ -14,22 +14,34 @@
       "default": "./lib/core/index.js"
     },
     "./browser": {
-      "node": null,
       "types": "./lib/browser/index.d.ts",
+      "browser": {
+        "require": "./lib/browser/index.js",
+        "import": "./lib/browser/index.mjs"
+      },
+      "node": null,
       "require": "./lib/browser/index.js",
       "import": "./lib/browser/index.mjs",
       "default": "./lib/browser/index.js"
     },
     "./node": {
-      "browser": null,
       "types": "./lib/node/index.d.ts",
+      "node": {
+        "require": "./lib/node/index.js",
+        "import": "./lib/node/index.mjs"
+      },
+      "browser": null,
       "require": "./lib/node/index.js",
       "import": "./lib/node/index.mjs",
       "default": "./lib/node/index.mjs"
     },
     "./native": {
-      "browser": null,
       "types": "./lib/native/index.d.ts",
+      "react-native": {
+        "require": "./lib/native/index.js",
+        "import": "./lib/native/index.mjs"
+      },
+      "browser": null,
       "require": "./lib/native/index.js",
       "import": "./lib/native/index.mjs",
       "default": "./lib/native/index.js"
@@ -55,26 +67,6 @@
   "engines": {
     "node": ">=18"
   },
-  "scripts": {
-    "start": "tsup --watch",
-    "clean": "rimraf ./lib",
-    "lint": "eslint \"{cli,config,src,test}/**/*.ts\"",
-    "build": "pnpm clean && cross-env NODE_ENV=production tsup && pnpm patch:dts",
-    "patch:dts": "node \"./config/scripts/patch-ts.js\"",
-    "check:exports": "node \"./config/scripts/validate-esm.js\"",
-    "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native",
-    "test:unit": "vitest",
-    "test:node": "vitest run --config=./test/node/vitest.config.ts",
-    "test:native": "vitest --config=./test/native/vitest.config.ts",
-    "test:browser": "playwright test -c ./test/browser/playwright.config.ts",
-    "test:modules:node": "vitest run --config=./test/modules/node/vitest.config.ts",
-    "test:modules:browser": "playwright test -c ./test/modules/browser/playwright.config.ts",
-    "test:ts": "vitest --typecheck --config=./test/typings/vitest.config.ts",
-    "prepare": "pnpm simple-git-hooks init",
-    "prepack": "pnpm build",
-    "release": "release publish",
-    "postinstall": "node -e \"try{require('./config/scripts/postinstall')}catch(e){}\""
-  },
   "lint-staged": {
     "**/*.ts": [
       "eslint --fix"
@@ -125,7 +117,7 @@
     "@bundled-es-modules/statuses": "^1.0.1",
     "@inquirer/confirm": "^3.0.0",
     "@mswjs/cookies": "^1.1.0",
-    "@mswjs/interceptors": "^0.27.1",
+    "@mswjs/interceptors": "^0.29.0",
     "@open-draft/until": "^2.1.0",
     "@types/cookie": "^0.6.0",
     "@types/statuses": "^2.0.4",
@@ -142,7 +134,6 @@
   "devDependencies": {
     "@commitlint/cli": "^18.4.4",
     "@commitlint/config-conventional": "^18.4.4",
-    "@fastify/websocket": "^8.3.1",
     "@open-draft/test-server": "^0.4.2",
     "@ossjs/release": "^0.8.1",
     "@playwright/test": "^1.40.1",
@@ -152,7 +143,6 @@
     "@types/glob": "^8.1.0",
     "@types/json-bigint": "^1.0.4",
     "@types/node": "18.x",
-    "@types/ws": "^8.5.10",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "@web/dev-server": "^0.1.38",
@@ -168,7 +158,6 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "express": "^4.18.2",
-    "fastify": "^4.26.0",
     "fs-extra": "^11.2.0",
     "fs-teardown": "^0.3.0",
     "glob": "^10.3.10",
@@ -207,5 +196,23 @@
     "pre-commit": "pnpm lint-staged",
     "prepare-commit-msg": "grep -qE '^[^#]' .git/COMMIT_EDITMSG || (exec < /dev/tty && pnpm cz --hook || true)",
     "commit-msg": "pnpm commitlint --edit $1"
+  },
+  "scripts": {
+    "start": "tsup --watch",
+    "clean": "rimraf ./lib",
+    "lint": "eslint \"{cli,config,src,test}/**/*.ts\"",
+    "build": "pnpm clean && cross-env NODE_ENV=production tsup && pnpm patch:dts",
+    "patch:dts": "node \"./config/scripts/patch-ts.js\"",
+    "check:exports": "node \"./config/scripts/validate-esm.js\"",
+    "test": "pnpm test:unit && pnpm test:node && pnpm test:browser && pnpm test:native",
+    "test:unit": "vitest",
+    "test:node": "vitest run --config=./test/node/vitest.config.ts",
+    "test:native": "vitest --config=./test/native/vitest.config.ts",
+    "test:browser": "playwright test -c ./test/browser/playwright.config.ts",
+    "test:modules:node": "vitest --config=./test/modules/node/vitest.config.ts",
+    "test:modules:browser": "playwright test -c ./test/modules/browser/playwright.config.ts",
+    "test:ts": "vitest --typecheck --config=./test/typings/vitest.config.ts",
+    "release": "release publish",
+    "postinstall": "node -e \"try{require('./config/scripts/postinstall')}catch(e){}\""
   }
-}
+}

package/src/browser/setupWorker/glossary.ts

@@ -5,11 +5,13 @@ import {
   SharedOptions,
 } from '~/core/sharedOptions'
 import { ServiceWorkerMessage } from './start/utils/createMessageChannel'
-import { RequestHandler } from '~/core/handlers/RequestHandler'
+import {
+  RequestHandler,
+  RequestHandlerDefaultInfo,
+} from '~/core/handlers/RequestHandler'
 import type { HttpRequestEventMap, Interceptor } from '@mswjs/interceptors'
-import type { Path } from '~/core/utils/matching/matchRequestUrl'
-import type { RequiredDeep } from '~/core/typeUtils'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
+import { Path } from '~/core/utils/matching/matchRequestUrl'
+import { RequiredDeep } from '~/core/typeUtils'
 
 export type ResolvedPath = Path | URL
 
@@ -85,7 +87,7 @@ export interface SetupWorkerInternalContext {
   startOptions: RequiredDeep<StartOptions>
   worker: ServiceWorker | null
   registration: ServiceWorkerRegistration | null
-  getRequestHandlers(): Array<RequestHandler | WebSocketHandler>
+  getRequestHandlers(): Array<RequestHandler>
   requests: Map<string, Request>
   emitter: Emitter<LifeCycleEventsMap>
   keepAliveInterval?: number
@@ -209,7 +211,7 @@ export interface SetupWorker {
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/use `worker.use()` API reference}
    */
-  use: (...handlers: Array<RequestHandler | WebSocketHandler>) => void
+  use: (...handlers: RequestHandler[]) => void
 
   /**
    * Marks all request handlers that respond using `res.once()` as unused.
@@ -224,16 +226,14 @@ export interface SetupWorker {
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/reset-handlers `worker.resetHandlers()` API reference}
    */
-  resetHandlers: (
-    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
-  ) => void
+  resetHandlers: (...nextHandlers: RequestHandler[]) => void
 
   /**
    * Returns a readonly list of currently active request handlers.
    *
    * @see {@link https://mswjs.io/docs/api/setup-worker/list-handlers `worker.listHandlers()` API reference}
    */
-  listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler>
+  listHandlers(): ReadonlyArray<RequestHandler<RequestHandlerDefaultInfo, any>>
 
   /**
    * Life-cycle events.

package/src/browser/setupWorker/setupWorker.ts

@@ -18,13 +18,9 @@ import { createFallbackStop } from './stop/createFallbackStop'
 import { devUtils } from '~/core/utils/internal/devUtils'
 import { SetupApi } from '~/core/SetupApi'
 import { mergeRight } from '~/core/utils/internal/mergeRight'
-import type { LifeCycleEventsMap } from '~/core/sharedOptions'
-import type { WebSocketHandler } from '~/core/handlers/WebSocketHandler'
+import { LifeCycleEventsMap } from '~/core/sharedOptions'
 import { SetupWorker } from './glossary'
 import { supportsReadableStreamTransfer } from '../utils/supportsReadableStreamTransfer'
-import { webSocketInterceptor } from '~/core/ws/webSocketInterceptor'
-import { handleWebSocketEvent } from '~/core/ws/handleWebSocketEvent'
-import { attachWebSocketLogger } from '~/core/ws/utils/attachWebSocketLogger'
 
 interface Listener {
   target: EventTarget
@@ -41,7 +37,7 @@ export class SetupWorkerApi
   private stopHandler: StopHandler = null as any
   private listeners: Array<Listener>
 
-  constructor(...handlers: Array<RequestHandler | WebSocketHandler>) {
+  constructor(...handlers: Array<RequestHandler>) {
     super(...handlers)
 
     invariant(
@@ -180,31 +176,6 @@ export class SetupWorkerApi
       options,
     ) as SetupWorkerInternalContext['startOptions']
 
-    // Enable WebSocket interception.
-    handleWebSocketEvent({
-      getHandlers: () => {
-        return this.handlersController.currentHandlers()
-      },
-      onMockedConnection: (connection) => {
-        if (!this.context.startOptions.quiet) {
-          // Attach the logger for mocked connections since
-          // those won't be visible in the browser's devtools.
-          attachWebSocketLogger(connection)
-        }
-      },
-      onPassthroughConnection() {
-        /**
-         * @fixme Call some "onUnhandledConnection".
-         */
-      },
-    })
-
-    webSocketInterceptor.apply()
-
-    this.subscriptions.push(() => {
-      webSocketInterceptor.dispose()
-    })
-
     return await this.startHandler(this.context.startOptions, options)
   }
 
@@ -222,8 +193,6 @@ export class SetupWorkerApi
  *
  * @see {@link https://mswjs.io/docs/api/setup-worker `setupWorker()` API reference}
  */
-export function setupWorker(
-  ...handlers: Array<RequestHandler | WebSocketHandler>
-): SetupWorker {
+export function setupWorker(...handlers: Array<RequestHandler>): SetupWorker {
   return new SetupWorkerApi(...handlers)
 }

package/src/core/SetupApi.ts

@@ -1,42 +1,38 @@
 import { invariant } from 'outvariant'
 import { EventMap, Emitter } from 'strict-event-emitter'
-import { RequestHandler } from './handlers/RequestHandler'
+import {
+  RequestHandler,
+  RequestHandlerDefaultInfo,
+} from './handlers/RequestHandler'
 import { LifeCycleEventEmitter } from './sharedOptions'
 import { devUtils } from './utils/internal/devUtils'
 import { pipeEvents } from './utils/internal/pipeEvents'
 import { toReadonlyArray } from './utils/internal/toReadonlyArray'
 import { Disposable } from './utils/internal/Disposable'
-import type { WebSocketHandler } from './handlers/WebSocketHandler'
 
 export abstract class HandlersController {
-  abstract prepend(
-    runtimeHandlers: Array<RequestHandler | WebSocketHandler>,
-  ): void
-  abstract reset(nextHandles: Array<RequestHandler | WebSocketHandler>): void
-  abstract currentHandlers(): Array<RequestHandler | WebSocketHandler>
+  abstract prepend(runtimeHandlers: Array<RequestHandler>): void
+  abstract reset(nextHandles: Array<RequestHandler>): void
+  abstract currentHandlers(): Array<RequestHandler>
 }
 
 export class InMemoryHandlersController implements HandlersController {
-  private handlers: Array<RequestHandler | WebSocketHandler>
+  private handlers: Array<RequestHandler>
 
-  constructor(
-    private initialHandlers: Array<RequestHandler | WebSocketHandler>,
-  ) {
+  constructor(private initialHandlers: Array<RequestHandler>) {
     this.handlers = [...initialHandlers]
   }
 
-  public prepend(
-    runtimeHandles: Array<RequestHandler | WebSocketHandler>,
-  ): void {
+  public prepend(runtimeHandles: Array<RequestHandler>): void {
     this.handlers.unshift(...runtimeHandles)
   }
 
-  public reset(nextHandlers: Array<RequestHandler | WebSocketHandler>): void {
+  public reset(nextHandlers: Array<RequestHandler>): void {
     this.handlers =
       nextHandlers.length > 0 ? [...nextHandlers] : [...this.initialHandlers]
   }
 
-  public currentHandlers(): Array<RequestHandler | WebSocketHandler> {
+  public currentHandlers(): Array<RequestHandler> {
     return this.handlers
   }
 }
@@ -51,7 +47,7 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
 
   public readonly events: LifeCycleEventEmitter<EventsMap>
 
-  constructor(...initialHandlers: Array<RequestHandler | WebSocketHandler>) {
+  constructor(...initialHandlers: Array<RequestHandler>) {
     super()
 
     invariant(
@@ -75,14 +71,12 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
     })
   }
 
-  private validateHandlers(handlers: ReadonlyArray<unknown>): boolean {
+  private validateHandlers(handlers: ReadonlyArray<RequestHandler>): boolean {
     // Guard against incorrect call signature of the setup API.
     return handlers.every((handler) => !Array.isArray(handler))
   }
 
-  public use(
-    ...runtimeHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
+  public use(...runtimeHandlers: Array<RequestHandler>): void {
     invariant(
       this.validateHandlers(runtimeHandlers),
       devUtils.formatMessage(
@@ -95,19 +89,17 @@ export abstract class SetupApi<EventsMap extends EventMap> extends Disposable {
 
   public restoreHandlers(): void {
     this.handlersController.currentHandlers().forEach((handler) => {
-      if ('isUsed' in handler) {
-        handler.isUsed = false
-      }
+      handler.isUsed = false
     })
   }
 
-  public resetHandlers(
-    ...nextHandlers: Array<RequestHandler | WebSocketHandler>
-  ): void {
+  public resetHandlers(...nextHandlers: Array<RequestHandler>): void {
     this.handlersController.reset(nextHandlers)
   }
 
-  public listHandlers(): ReadonlyArray<RequestHandler | WebSocketHandler> {
+  public listHandlers(): ReadonlyArray<
+    RequestHandler<RequestHandlerDefaultInfo, any, any>
+  > {
     return toReadonlyArray(this.handlersController.currentHandlers())
   }
 

package/src/core/index.ts

@@ -2,20 +2,13 @@ import { checkGlobals } from './utils/internal/checkGlobals'
 
 export { SetupApi } from './SetupApi'
 
-/* HTTP handlers */
+/* Request handlers */
 export { RequestHandler } from './handlers/RequestHandler'
 export { http } from './http'
 export { HttpHandler, HttpMethods } from './handlers/HttpHandler'
 export { graphql } from './graphql'
 export { GraphQLHandler } from './handlers/GraphQLHandler'
 
-/* WebSocket handler */
-export { ws, type WebSocketLink } from './ws'
-export {
-  WebSocketHandler,
-  type WebSocketHandlerEventMap,
-} from './handlers/WebSocketHandler'
-
 /* Utils */
 export { matchRequestUrl } from './utils/matching/matchRequestUrl'
 export * from './utils/handleRequest'

package/src/core/utils/executeHandlers.ts

@@ -1,6 +1,6 @@
 import {
   RequestHandler,
-  type RequestHandlerExecutionResult,
+  RequestHandlerExecutionResult,
 } from '../handlers/RequestHandler'
 
 export interface HandlersExecutionResult {
@@ -18,7 +18,7 @@ export interface ResponseResolutionContext {
  * Returns the execution result object containing any matching request
  * handler and any mocked response it returned.
  */
-export const executeHandlers = async <Handlers extends Array<unknown>>({
+export const executeHandlers = async <Handlers extends Array<RequestHandler>>({
   request,
   requestId,
   handlers,
@@ -33,10 +33,6 @@ export const executeHandlers = async <Handlers extends Array<unknown>>({
   let result: RequestHandlerExecutionResult<any> | null = null
 
   for (const handler of handlers) {
-    if (!(handler instanceof RequestHandler)) {
-      continue
-    }
-
     result = await handler.run({ request, requestId, resolutionContext })
 
     // If the handler produces some result for this request,

package/src/core/utils/handleRequest.ts

@@ -1,5 +1,6 @@
 import { until } from '@open-draft/until'
 import { Emitter } from 'strict-event-emitter'
+import { RequestHandler } from '../handlers/RequestHandler'
 import { LifeCycleEventsMap, SharedOptions } from '../sharedOptions'
 import { RequiredDeep } from '../typeUtils'
 import { HandlersExecutionResult, executeHandlers } from './executeHandlers'
@@ -44,7 +45,7 @@ export interface HandleRequestOptions {
 export async function handleRequest(
   request: Request,
   requestId: string,
-  handlers: Array<unknown>,
+  handlers: Array<RequestHandler>,
   options: RequiredDeep<SharedOptions>,
   emitter: Emitter<LifeCycleEventsMap>,
   handleRequestOptions?: HandleRequestOptions,

package/src/core/utils/internal/Disposable.ts

@@ -1,9 +1,12 @@
-export type DisposableSubscription = () => Promise<void> | void
+export type DisposableSubscription = () => void
 
 export class Disposable {
   protected subscriptions: Array<DisposableSubscription> = []
 
-  public async dispose() {
-    await Promise.all(this.subscriptions.map((subscription) => subscription()))
+  public dispose() {
+    let subscription: DisposableSubscription | undefined
+    while ((subscription = this.subscriptions.shift())) {
+      subscription()
+    }
   }
 }

package/src/core/utils/internal/devUtils.test.ts

@@ -0,0 +1,21 @@
+import { InternalError } from './devUtils'
+
+describe(InternalError, () => {
+  it('creates an InternalError instance', () => {
+    const error = new InternalError('Message')
+
+    expect(error.name).toBe('InternalError')
+    expect(error.message).toBe('Message')
+    expect(error.toString()).toBe('InternalError: Message')
+    expect(error.stack).toMatch(/\w+/)
+  })
+
+  it('passes the identity check', () => {
+    const error = new InternalError('Message')
+    expect(error instanceof InternalError).toBe(true)
+    expect(error instanceof Error).toBe(true)
+
+    const extraneousError = new Error('Message')
+    expect(extraneousError).not.toBeInstanceOf(InternalError)
+  })
+})

package/src/core/utils/internal/devUtils.ts

@@ -29,3 +29,16 @@ export const devUtils = {
   warn,
   error,
 }
+
+/**
+ * Internal error instance.
+ * Used to differentiate the library errors that must be forwarded
+ * to the user from the unhandled exceptions. Use this if you don't
+ * wish for the error to be coerced to a 500 fallback response.
+ */
+export class InternalError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'InternalError'
+  }
+}

package/src/core/utils/logging/getTimestamp.test.ts

@@ -1,32 +1,18 @@
 import { getTimestamp } from './getTimestamp'
 
 beforeAll(() => {
-  vi.useFakeTimers()
+  // Stub native `Date` prototype methods used in the tested module,
+  // to always produce a predictable value for testing purposes.
+  vi.spyOn(global.Date.prototype, 'getHours').mockImplementation(() => 12)
+  vi.spyOn(global.Date.prototype, 'getMinutes').mockImplementation(() => 4)
+  vi.spyOn(global.Date.prototype, 'getSeconds').mockImplementation(() => 8)
 })
 
 afterAll(() => {
-  vi.useRealTimers()
+  vi.restoreAllMocks()
 })
 
 test('returns a timestamp string of the invocation time', () => {
-  vi.setSystemTime(new Date('2024-01-01 12:4:8'))
   const timestamp = getTimestamp()
   expect(timestamp).toBe('12:04:08')
 })
-
-test('returns a timestamp with milliseconds', () => {
-  vi.setSystemTime(new Date('2024-01-01 12:4:8'))
-  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.000')
-
-  vi.setSystemTime(new Date('2024-01-01 12:4:8.000'))
-  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.000')
-
-  vi.setSystemTime(new Date('2024-01-01 12:4:8.4'))
-  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.400')
-
-  vi.setSystemTime(new Date('2024-01-01 12:4:8.123'))
-  expect(getTimestamp({ milliseconds: true })).toBe('12:04:08.123')
-
-  vi.setSystemTime(new Date('2024-01-01 12:00:00'))
-  expect(getTimestamp({ milliseconds: true })).toBe('12:00:00.000')
-})

package/src/core/utils/logging/getTimestamp.ts

@@ -1,17 +1,12 @@
-interface GetTimestampOptions {
-  milliseconds?: boolean
-}
-
 /**
  * Returns a timestamp string in a "HH:MM:SS" format.
  */
-export function getTimestamp(options?: GetTimestampOptions): string {
+export function getTimestamp(): string {
   const now = new Date()
-  const timestamp = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`
-
-  if (options?.milliseconds) {
-    return `${timestamp}.${now.getMilliseconds().toString().padStart(3, '0')}`
-  }
 
-  return timestamp
+  return [now.getHours(), now.getMinutes(), now.getSeconds()]
+    .map(String)
+    .map((chunk) => chunk.slice(0, 2))
+    .map((chunk) => chunk.padStart(2, '0'))
+    .join(':')
 }

package/src/core/utils/matching/matchRequestUrl.test.ts

@@ -61,50 +61,6 @@ describe('matchRequestUrl', () => {
     expect(match).toHaveProperty('matches', false)
     expect(match).toHaveProperty('params', {})
   })
-
-  test('returns true for matching WebSocket URL', () => {
-    expect(
-      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://test.mswjs.io'),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-    expect(
-      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://test.mswjs.io'),
-    ).toEqual({
-      matches: true,
-      params: {},
-    })
-  })
-
-  test('returns false for non-matching WebSocket URL', () => {
-    expect(
-      matchRequestUrl(new URL('ws://test.mswjs.io'), 'ws://foo.mswjs.io'),
-    ).toEqual({
-      matches: false,
-      params: {},
-    })
-    expect(
-      matchRequestUrl(new URL('wss://test.mswjs.io'), 'wss://completely.diff'),
-    ).toEqual({
-      matches: false,
-      params: {},
-    })
-  })
-
-  test('returns path parameters when matched a WebSocket URL', () => {
-    expect(
-      matchRequestUrl(
-        new URL('wss://test.mswjs.io'),
-        'wss://:service.mswjs.io',
-      ),
-    ).toEqual({
-      matches: true,
-      params: {
-        service: 'test',
-      },
-    })
-  })
 })
 
 describe('coercePath', () => {

package/src/core/utils/matching/matchRequestUrl.ts

@@ -71,7 +71,3 @@ export function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match {
     params,
   }
 }
-
-export function isPath(value: unknown): value is Path {
-  return typeof value === 'string' || value instanceof RegExp
-}

package/src/core/utils/request/onUnhandledRequest.test.ts

@@ -7,10 +7,10 @@ import {
 } from './onUnhandledRequest'
 
 const fixtures = {
-  warningWithoutSuggestions: `\
+  warningWithoutSuggestions: (url = `/api`) => `\
 [MSW] Warning: intercepted a request without a matching request handler:
 
-  • GET /api
+  • GET ${url}
 
 If you still wish to intercept this unhandled request, please create a request handler for it.
 Read more: https://mswjs.io/docs/getting-started/mocks`,
@@ -46,7 +46,9 @@ test('supports the "bypass" request strategy', async () => {
 test('supports the "warn" request strategy', async () => {
   await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(),
+  )
 })
 
 test('supports the "error" request strategy', async () => {
@@ -103,7 +105,9 @@ test('supports calling default strategies from the custom callback function', as
 test('does not print any suggestions given no handlers to suggest', async () => {
   await onUnhandledRequest(new Request(new URL('http://localhost/api')), 'warn')
 
-  expect(console.warn).toHaveBeenCalledWith(fixtures.warningWithoutSuggestions)
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(),
+  )
 })
 
 test('throws an exception given unknown request strategy', async () => {
@@ -117,3 +121,25 @@ test('throws an exception given unknown request strategy', async () => {
     '[MSW] Failed to react to an unhandled request: unknown strategy "invalid-strategy". Please provide one of the supported strategies ("bypass", "warn", "error") or a custom callback function as the value of the "onUnhandledRequest" option.',
   )
 })
+
+test('prints with a relative URL and search params', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('http://localhost/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`/api?foo=boo`),
+  )
+})
+
+test('prints with an absolute URL and search params', async () => {
+  await onUnhandledRequest(
+    new Request(new URL('https://mswjs.io/api?foo=boo')),
+    'warn',
+  )
+
+  expect(console.warn).toHaveBeenCalledWith(
+    fixtures.warningWithoutSuggestions(`https://mswjs.io/api?foo=boo`),
+  )
+})