msw 2.0.12 → 2.0.13

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

@@ -0,0 +1,77 @@
+/**
+ * @vitest-environment node
+ */
+import { encodeBuffer } from '@mswjs/interceptors'
+import { serializeResponse } from './serializeResponse'
+
+it('serializes response without body', async () => {
+  const result = await serializeResponse(new Response(null))
+
+  expect(result.status).toBe(200)
+  expect(result.statusText).toBe('OK')
+  expect(result.headers).toEqual({})
+  expect(result.body).toBe('')
+})
+
+it('serializes a plain text response', async () => {
+  const result = await serializeResponse(
+    new Response('hello world', {
+      status: 201,
+      statusText: 'Created',
+      headers: {
+        'Content-Type': 'text/plain',
+      },
+    }),
+  )
+
+  expect(result.status).toBe(201)
+  expect(result.statusText).toBe('Created')
+  expect(result.headers).toEqual({
+    'content-type': 'text/plain',
+  })
+  expect(result.body).toBe('hello world')
+})
+
+it('serializes a JSON response', async () => {
+  const response = new Response(JSON.stringify({ users: ['John'] }), {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+  })
+  const result = await serializeResponse(response)
+
+  expect(result.headers).toEqual({
+    'content-type': 'application/json',
+  })
+  expect(result.body).toBe(JSON.stringify({ users: ['John'] }))
+})
+
+it('serializes a ArrayBuffer response', async () => {
+  const data = encodeBuffer('hello world')
+  const response = new Response(data)
+  const result = await serializeResponse(response)
+
+  expect(result.body).toBe('hello world')
+})
+
+it('serializes a Blob response', async () => {
+  const response = new Response(new Blob(['hello world']))
+  const result = await serializeResponse(response)
+
+  expect(result.body).toBe('hello world')
+})
+
+it('serializes a FormData response', async () => {
+  const data = new FormData()
+  data.set('firstName', 'Alice')
+  data.set('age', '32')
+  const response = new Response(data)
+  const result = await serializeResponse(response)
+
+  expect(result.body).toContain(
+    `Content-Disposition: form-data; name="firstName"\r\n\r\nAlice`,
+  )
+  expect(result.body).toContain(
+    `Content-Disposition: form-data; name="age"\r\n\r\n32`,
+  )
+})

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

@@ -0,0 +1,31 @@
+import statuses from '@bundled-es-modules/statuses'
+
+const { message } = statuses
+
+export interface SerializedResponse {
+  status: number
+  statusText: string
+  headers: Record<string, any>
+  body: string
+}
+
+export async function serializeResponse(
+  response: Response,
+): Promise<SerializedResponse> {
+  const responseClone = response.clone()
+  const responseText = await responseClone.text()
+
+  // Normalize the response status and status text when logging
+  // since the default Response instance doesn't infer status texts
+  // from status codes. This has no effect on the actual response instance.
+  const responseStatus = responseClone.status || 200
+  const responseStatusText =
+    responseClone.statusText || message[responseStatus] || 'OK'
+
+  return {
+    status: responseStatus,
+    statusText: responseStatusText,
+    headers: Object.fromEntries(responseClone.headers.entries()),
+    body: responseText,
+  }
+}

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

@@ -0,0 +1,114 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { coercePath, matchRequestUrl } from './matchRequestUrl'
+
+describe('matchRequestUrl', () => {
+  test('returns true when matches against an exact URL', () => {
+    const match = matchRequestUrl(
+      new URL('https://test.mswjs.io'),
+      'https://test.mswjs.io',
+    )
+    expect(match).toHaveProperty('matches', true)
+    expect(match).toHaveProperty('params', {})
+  })
+
+  test('returns true when matched against a wildcard', () => {
+    const match = matchRequestUrl(new URL('https://test.mswjs.io'), '*')
+    expect(match).toHaveProperty('matches', true)
+    expect(match).toHaveProperty('params', {
+      '0': 'https://test.mswjs.io/',
+    })
+  })
+
+  test('returns true when matched against a RegExp', () => {
+    const match = matchRequestUrl(
+      new URL('https://test.mswjs.io'),
+      /test\.mswjs\.io/,
+    )
+    expect(match).toHaveProperty('matches', true)
+    expect(match).toHaveProperty('params', {})
+  })
+
+  test('returns path parameters when matched', () => {
+    const match = matchRequestUrl(
+      new URL('https://test.mswjs.io/user/abc-123'),
+      'https://test.mswjs.io/user/:userId',
+    )
+    expect(match).toHaveProperty('matches', true)
+    expect(match).toHaveProperty('params', {
+      userId: 'abc-123',
+    })
+  })
+
+  test('decodes path parameters', () => {
+    const url = 'http://example.com:5001/example'
+    const match = matchRequestUrl(
+      new URL(`https://test.mswjs.io/reflect-url/${encodeURIComponent(url)}`),
+      'https://test.mswjs.io/reflect-url/:url',
+    )
+    expect(match).toHaveProperty('matches', true)
+    expect(match).toHaveProperty('params', {
+      url,
+    })
+  })
+
+  test('returns false when does not match against the request URL', () => {
+    const match = matchRequestUrl(
+      new URL('https://test.mswjs.io'),
+      'https://google.com',
+    )
+    expect(match).toHaveProperty('matches', false)
+    expect(match).toHaveProperty('params', {})
+  })
+})
+
+describe('coercePath', () => {
+  test('escapes the colon in protocol', () => {
+    expect(coercePath('https://example.com')).toEqual('https\\://example.com')
+    expect(coercePath('https://example.com/:userId')).toEqual(
+      'https\\://example.com/:userId',
+    )
+    expect(coercePath('http://localhost:3000')).toEqual(
+      'http\\://localhost\\:3000',
+    )
+  })
+
+  test('escapes the colon before the port number', () => {
+    expect(coercePath('localhost:8080')).toEqual('localhost\\:8080')
+    expect(coercePath('http://127.0.0.1:8080')).toEqual(
+      'http\\://127.0.0.1\\:8080',
+    )
+    expect(coercePath('https://example.com:1234')).toEqual(
+      'https\\://example.com\\:1234',
+    )
+
+    expect(coercePath('localhost:8080/:5678')).toEqual('localhost\\:8080/:5678')
+    expect(coercePath('https://example.com:8080/:5678')).toEqual(
+      'https\\://example.com\\:8080/:5678',
+    )
+  })
+
+  test('replaces wildcard with an unnnamed capturing group', () => {
+    expect(coercePath('*')).toEqual('(.*)')
+    expect(coercePath('**')).toEqual('(.*)')
+    expect(coercePath('/us*')).toEqual('/us(.*)')
+    expect(coercePath('/user/*')).toEqual('/user/(.*)')
+    expect(coercePath('https://example.com/user/*')).toEqual(
+      'https\\://example.com/user/(.*)',
+    )
+    expect(coercePath('https://example.com/us*')).toEqual(
+      'https\\://example.com/us(.*)',
+    )
+  })
+
+  test('preserves path parameter modifiers', () => {
+    expect(coercePath(':name*')).toEqual(':name*')
+    expect(coercePath('/foo/:name*')).toEqual('/foo/:name*')
+    expect(coercePath('/foo/**:name*')).toEqual('/foo/(.*):name*')
+    expect(coercePath('**/foo/*/:name*')).toEqual('(.*)/foo/(.*)/:name*')
+    expect(coercePath('/foo/:first/bar/:second*/*')).toEqual(
+      '/foo/:first/bar/:second*/(.*)',
+    )
+  })
+})

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

@@ -0,0 +1,73 @@
+import { match } from 'path-to-regexp'
+import { getCleanUrl } from '@mswjs/interceptors'
+import { normalizePath } from './normalizePath'
+
+export type Path = string | RegExp
+export type PathParams<KeyType extends keyof any = string> = {
+  [ParamName in KeyType]: string | ReadonlyArray<string>
+}
+
+export interface Match {
+  matches: boolean
+  params?: PathParams
+}
+
+/**
+ * Coerce a path supported by MSW into a path
+ * supported by "path-to-regexp".
+ */
+export function coercePath(path: string): string {
+  return (
+    path
+      /**
+       * Replace wildcards ("*") with unnamed capturing groups
+       * because "path-to-regexp" doesn't support wildcards.
+       * Ignore path parameter' modifiers (i.e. ":name*").
+       */
+      .replace(
+        /([:a-zA-Z_-]*)(\*{1,2})+/g,
+        (_, parameterName: string | undefined, wildcard: string) => {
+          const expression = '(.*)'
+
+          if (!parameterName) {
+            return expression
+          }
+
+          return parameterName.startsWith(':')
+            ? `${parameterName}${wildcard}`
+            : `${parameterName}${expression}`
+        },
+      )
+      /**
+       * Escape the port so that "path-to-regexp" can match
+       * absolute URLs including port numbers.
+       */
+      .replace(/([^\/])(:)(?=\d+)/, '$1\\$2')
+      /**
+       * Escape the protocol so that "path-to-regexp" could match
+       * absolute URL.
+       * @see https://github.com/pillarjs/path-to-regexp/issues/259
+       */
+      .replace(/^([^\/]+)(:)(?=\/\/)/, '$1\\$2')
+  )
+}
+
+/**
+ * Returns the result of matching given request URL against a mask.
+ */
+export function matchRequestUrl(url: URL, path: Path, baseUrl?: string): Match {
+  const normalizedPath = normalizePath(path, baseUrl)
+  const cleanPath =
+    typeof normalizedPath === 'string'
+      ? coercePath(normalizedPath)
+      : normalizedPath
+
+  const cleanUrl = getCleanUrl(url)
+  const result = match(cleanPath, { decode: decodeURIComponent })(cleanUrl)
+  const params = (result && (result.params as PathParams)) || {}
+
+  return {
+    matches: result !== false,
+    params,
+  }
+}

package/src/core/utils/matching/normalizePath.node.test.ts

@@ -0,0 +1,44 @@
+/**
+ * @vitest-environment node
+ */
+import { normalizePath } from './normalizePath'
+
+test('returns RegExp as-is', () => {
+  const path = /s/
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a clean absolute URL as-is', () => {
+  const path = 'https://test.mswjs.io/path'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a relative URL as-is given a string path', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('rebases a relative URL against a custom base URL', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path, 'https://test.mswjs.io')).toEqual(
+    'https://test.mswjs.io/relative/url',
+  )
+})
+
+test('removes query parameters and hashes from an absolute URL', () => {
+  expect(normalizePath('https://test.mswjs.io/user?query=123')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+  expect(normalizePath('https://test.mswjs.io/user#some')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+  expect(normalizePath('https://test.mswjs.io/user?query=123#some')).toEqual(
+    'https://test.mswjs.io/user',
+  )
+})
+
+test('removes query parameters and hashes from a relative URL', () => {
+  expect(normalizePath('/user?query=123')).toEqual('/user')
+  expect(normalizePath('/user#some')).toEqual('/user')
+  expect(normalizePath('/user?query=123#some')).toEqual('/user')
+})

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

@@ -0,0 +1,50 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { normalizePath } from './normalizePath'
+
+test('returns RegExp as-is', () => {
+  const path = /\/user\/(.+?)\//
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('returns a clean absolute URL as-is', () => {
+  const path = 'https://test.mswjs.io/user'
+  expect(normalizePath(path)).toEqual(path)
+})
+
+test('rebases a relative URL against the current location', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path)).toBe(`${location.origin}/relative/url`)
+})
+
+test('rebases a relative URL against a custom base URL', () => {
+  const path = '/relative/url'
+  expect(normalizePath(path, 'https://test.mswjs.io')).toEqual(
+    'https://test.mswjs.io/relative/url',
+  )
+})
+
+test('removes query parameters and hashes from an absolute URL', () => {
+  const path = 'https://test.mswjs.io/user?query=123#some'
+  expect(normalizePath(path)).toEqual('https://test.mswjs.io/user')
+})
+
+test('removes query parameters and hashes from a relative URL', () => {
+  expect(normalizePath('/user?query=123')).toEqual(`${location.origin}/user`)
+  expect(normalizePath('/user#some')).toEqual(`${location.origin}/user`)
+  expect(normalizePath('/user?query=123#some')).toEqual(
+    `${location.origin}/user`,
+  )
+})
+
+test('returns a path pattern string as-is', () => {
+  expect(normalizePath(':api/user')).toEqual('http://localhost/:api/user')
+  expect(normalizePath('*/resource/*')).toEqual('*/resource/*')
+})
+
+test('removeß query parameters and hashes from a path pattern string', () => {
+  expect(normalizePath(':api/user?query=123#some')).toEqual(
+    'http://localhost/:api/user',
+  )
+})

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

@@ -0,0 +1,21 @@
+import type { Path } from './matchRequestUrl'
+import { cleanUrl } from '../url/cleanUrl'
+import { getAbsoluteUrl } from '../url/getAbsoluteUrl'
+
+/**
+ * Normalizes a given request handler path:
+ * - Preserves RegExp.
+ * - Removes query parameters and hashes.
+ * - Rebases relative URLs against the "baseUrl" or the current location.
+ * - Preserves relative URLs in Node.js, unless specified otherwise.
+ */
+export function normalizePath(path: Path, baseUrl?: string): Path {
+  // RegExp paths do not need normalization.
+  if (path instanceof RegExp) {
+    return path
+  }
+
+  const maybeAbsoluteUrl = getAbsoluteUrl(path, baseUrl)
+
+  return cleanUrl(maybeAbsoluteUrl)
+}

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

@@ -0,0 +1,26 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { getPublicUrlFromRequest } from './getPublicUrlFromRequest'
+
+test('returns an absolute request URL withouth search params', () => {
+  expect(
+    getPublicUrlFromRequest(new Request(new URL('https://test.mswjs.io/path'))),
+  ).toBe('https://test.mswjs.io/path')
+
+  expect(
+    getPublicUrlFromRequest(new Request(new URL('http://localhost/path'))),
+  ).toBe('/path')
+
+  expect(
+    getPublicUrlFromRequest(
+      new Request(new URL('http://localhost/path?foo=bar')),
+    ),
+  ).toBe('/path')
+})
+
+it('returns a relative URL given the request to the same origin', () => {
+  expect(getPublicUrlFromRequest(new Request('http://localhost/user'))).toBe(
+    '/user',
+  )
+})

package/src/core/utils/request/getPublicUrlFromRequest.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns a relative URL if the given request URL is relative to the current origin.
+ * Otherwise returns an absolute URL.
+ */
+export function getPublicUrlFromRequest(request: Request): string {
+  if (typeof location === 'undefined') {
+    return request.url
+  }
+
+  const url = new URL(request.url)
+
+  return url.origin === location.origin
+    ? url.pathname
+    : url.origin + url.pathname
+}

package/src/core/utils/request/getRequestCookies.node.test.ts

@@ -0,0 +1,29 @@
+/**
+ * @vitest-environment node
+ */
+import { getRequestCookies } from './getRequestCookies'
+
+const prevLocation = global.location
+
+beforeAll(() => {
+  // Node.js applications may polyfill some browser globals (document, location)
+  // when performing Server-Side Rendering of front-end applications.
+  global.location = {
+    href: 'https://mswjs.io',
+    origin: 'https://mswjs.io',
+  } as Location
+})
+
+afterAll(() => {
+  global.location = prevLocation
+})
+
+test('returns empty object when in a node environment with polyfilled location object', () => {
+  const cookies = getRequestCookies(
+    new Request(new URL('/user', location.href), {
+      credentials: 'include',
+    }),
+  )
+
+  expect(cookies).toEqual({})
+})

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

@@ -0,0 +1,64 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { getRequestCookies } from './getRequestCookies'
+import { clearCookies } from '../../../../test/support/utils'
+
+beforeAll(() => {
+  // Emulate some `document.cookie` value.
+  document.cookie = 'auth-token=abc-123;'
+  document.cookie = 'custom-cookie=yes;'
+  document.cookie = `encoded-cookie=${encodeURIComponent('测试')};`
+})
+
+afterAll(() => {
+  clearCookies()
+})
+
+test('returns all document cookies given "include" credentials', () => {
+  const cookies = getRequestCookies(
+    new Request(new URL('/user', location.origin), {
+      credentials: 'include',
+    }),
+  )
+
+  expect(cookies).toEqual({
+    'auth-token': 'abc-123',
+    'custom-cookie': 'yes',
+    'encoded-cookie': '测试',
+  })
+})
+
+test('returns all document cookies given "same-origin" credentials and the same request origin', () => {
+  const cookies = getRequestCookies(
+    new Request(new URL('/user', location.origin), {
+      credentials: 'same-origin',
+    }),
+  )
+
+  expect(cookies).toEqual({
+    'auth-token': 'abc-123',
+    'custom-cookie': 'yes',
+    'encoded-cookie': '测试',
+  })
+})
+
+test('returns an empty object given "same-origin" credentials and a different request origin', () => {
+  const cookies = getRequestCookies(
+    new Request(new URL('https://test.mswjs.io/user'), {
+      credentials: 'same-origin',
+    }),
+  )
+
+  expect(cookies).toEqual({})
+})
+
+test('returns an empty object given "omit" credentials', () => {
+  const cookies = getRequestCookies(
+    new Request(new URL('/user', location.origin), {
+      credentials: 'omit',
+    }),
+  )
+
+  expect(cookies).toEqual({})
+})

package/src/core/utils/request/getRequestCookies.ts

@@ -0,0 +1,75 @@
+import cookieUtils from '@bundled-es-modules/cookie'
+import { store } from '@mswjs/cookies'
+
+function getAllDocumentCookies() {
+  return cookieUtils.parse(document.cookie)
+}
+
+/** @todo Rename this to "getDocumentCookies" */
+/**
+ * Returns relevant document cookies based on the request `credentials` option.
+ */
+export function getRequestCookies(request: Request): Record<string, string> {
+  /**
+   * @note No cookies persist on the document in Node.js: no document.
+   */
+  if (typeof document === 'undefined' || typeof location === 'undefined') {
+    return {}
+  }
+
+  switch (request.credentials) {
+    case 'same-origin': {
+      const url = new URL(request.url)
+
+      // Return document cookies only when requested a resource
+      // from the same origin as the current document.
+      return location.origin === url.origin ? getAllDocumentCookies() : {}
+    }
+
+    case 'include': {
+      // Return all document cookies.
+      return getAllDocumentCookies()
+    }
+
+    default: {
+      return {}
+    }
+  }
+}
+
+export function getAllRequestCookies(request: Request): Record<string, string> {
+  const requestCookiesString = request.headers.get('cookie')
+  const cookiesFromHeaders = requestCookiesString
+    ? cookieUtils.parse(requestCookiesString)
+    : {}
+
+  store.hydrate()
+
+  const cookiesFromStore = Array.from(store.get(request)?.entries()).reduce<
+    Record<string, string>
+  >((cookies, [name, { value }]) => {
+    return Object.assign(cookies, { [name.trim()]: value })
+  }, {})
+
+  const cookiesFromDocument = getRequestCookies(request)
+
+  const forwardedCookies = {
+    ...cookiesFromDocument,
+    ...cookiesFromStore,
+  }
+
+  // Set the inferred cookies from the cookie store and the document
+  // on the request's headers.
+  /**
+   * @todo Consider making this a separate step so this function
+   * is pure-er.
+   */
+  for (const [name, value] of Object.entries(forwardedCookies)) {
+    request.headers.append('cookie', cookieUtils.serialize(name, value))
+  }
+
+  return {
+    ...forwardedCookies,
+    ...cookiesFromHeaders,
+  }
+}