@mswjs/interceptors 0.13.1 → 0.13.2

package/src/utils/getUrlByRequestOptions.test.ts

@@ -0,0 +1,140 @@
+import { Agent as HttpAgent } from 'http'
+import { RequestOptions, Agent as HttpsAgent } from 'https'
+import { getUrlByRequestOptions } from './getUrlByRequestOptions'
+
+test('returns a URL based on the basic RequestOptions', () => {
+  const options: RequestOptions = {
+    protocol: 'https:',
+    host: '127.0.0.1',
+    path: '/resource',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'https://127.0.0.1/resource')
+})
+
+test('inherits protocol and port from http.Agent, if set', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    path: '/',
+    agent: new HttpAgent(),
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('protocol', 'http:')
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'http://127.0.0.1/')
+})
+
+test('inherits protocol and port from https.Agent, if set', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    path: '/',
+    agent: new HttpsAgent({
+      port: 3080,
+    }),
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('protocol', 'https:')
+  expect(url).toHaveProperty('port', '3080')
+  expect(url).toHaveProperty('href', 'https://127.0.0.1:3080/')
+})
+
+test('resolves protocol to "http" given no explicit protocol and no certificate', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    path: '/',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('protocol', 'http:')
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'http://127.0.0.1/')
+})
+
+test('resolves protocol to "https" given no explicit protocol, but certificate', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    path: '/secure',
+    cert: '<!-- SSL certificate -->',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('protocol', 'https:')
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'https://127.0.0.1/secure')
+})
+
+test('resolves protocol to "https" given no explicit protocol, but port is 443', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    port: 443,
+    path: '/resource',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'https://127.0.0.1/resource')
+})
+
+test('resolves protocol to "https" given no explicit protocol, but agent port is 443', () => {
+  const options: RequestOptions = {
+    host: '127.0.0.1',
+    agent: new HttpsAgent({
+      port: 443,
+    }),
+    path: '/resource',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('port', '')
+  expect(url).toHaveProperty('href', 'https://127.0.0.1/resource')
+})
+
+test('inherits "port" if given', () => {
+  const options = {
+    protocol: 'http:',
+    host: '127.0.0.1',
+    port: 4002,
+    path: '/',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('port', '4002')
+  expect(url).toHaveProperty('protocol', 'http:')
+  expect(url).toHaveProperty('href', 'http://127.0.0.1:4002/')
+})
+
+test('inherits "username" and "password"', () => {
+  const options: RequestOptions = {
+    protocol: 'https:',
+    host: '127.0.0.1',
+    path: '/user',
+    auth: 'admin:abc-123',
+  }
+  const url = getUrlByRequestOptions(options)
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('username', 'admin')
+  expect(url).toHaveProperty('password', 'abc-123')
+  expect(url).toHaveProperty('protocol', 'https:')
+  expect(url).toHaveProperty('href', 'https://admin:abc-123@127.0.0.1/user')
+})
+
+test('resolves hostname to localhost if none provided', () => {
+  const url = getUrlByRequestOptions({})
+
+  expect(url).toBeInstanceOf(URL)
+  expect(url).toHaveProperty('protocol', 'http:')
+  expect(url).toHaveProperty('href', 'http://localhost/')
+})

package/src/utils/getUrlByRequestOptions.ts

@@ -0,0 +1,108 @@
+import { Agent } from 'http'
+import { RequestOptions, Agent as HttpsAgent } from 'https'
+
+const debug = require('debug')('utils getUrlByRequestOptions')
+
+// Request instance constructed by the "request" library
+// has a "self" property that has a "uri" field. This is
+// reproducible by performing a "XMLHttpRequest" request in JSDOM.
+export interface RequestSelf {
+  uri?: URL
+}
+
+export type ResolvedRequestOptions = RequestOptions & RequestSelf
+
+export const DEFAULT_PATH = '/'
+const DEFAULT_PROTOCOL = 'http:'
+const DEFAULT_HOST = 'localhost'
+const DEFAULT_PORT = 80
+const SSL_PORT = 443
+
+function getAgent(
+  options: ResolvedRequestOptions
+): Agent | HttpsAgent | undefined {
+  return options.agent instanceof Agent ? options.agent : undefined
+}
+
+function getProtocolByRequestOptions(options: ResolvedRequestOptions): string {
+  if (options.protocol) {
+    return options.protocol
+  }
+
+  const agent = getAgent(options)
+  const agentProtocol = (agent as RequestOptions)?.protocol
+
+  if (agentProtocol) {
+    return agentProtocol
+  }
+
+  const port = getPortByRequestOptions(options)
+  const isSecureRequest = options.cert || port === SSL_PORT
+
+  return isSecureRequest ? 'https:' : options.uri?.protocol || DEFAULT_PROTOCOL
+}
+
+function getPortByRequestOptions(
+  options: ResolvedRequestOptions
+): number | undefined {
+  const agent = getAgent(options)
+  const agentPort =
+    (agent as HttpsAgent)?.options.port ||
+    (agent as RequestOptions)?.defaultPort
+  const optionsPort = options.port
+
+  if (optionsPort || agentPort) {
+    const explicitPort = optionsPort || agentPort || DEFAULT_PORT
+    return Number(explicitPort)
+  }
+}
+
+function getHostByRequestOptions(options: ResolvedRequestOptions): string {
+  return options.hostname || options.host || DEFAULT_HOST
+}
+
+function getAuthByRequestOptions(options: ResolvedRequestOptions) {
+  if (options.auth) {
+    const [username, password] = options.auth.split(':')
+    return { username, password }
+  }
+}
+
+/**
+ * Creates a `URL` instance from a given `RequestOptions` object.
+ */
+export function getUrlByRequestOptions(options: ResolvedRequestOptions): URL {
+  debug('request options', options)
+
+  const protocol = getProtocolByRequestOptions(options)
+  const host = getHostByRequestOptions(options)
+  const port = getPortByRequestOptions(options)
+  const path = options.path || DEFAULT_PATH
+  const auth = getAuthByRequestOptions(options)
+
+  debug('protocol', protocol)
+  debug('host', host)
+  debug('port', port)
+  debug('path', path)
+
+  const baseUrl = `${protocol}//${host}`
+  debug('base URL:', baseUrl)
+
+  const url = options.uri ? new URL(options.uri.href) : new URL(path, baseUrl)
+
+  if (port) {
+    debug('detected explicit port', port)
+    url.port = port.toString()
+  }
+
+  if (auth) {
+    debug('resolved auth', auth)
+
+    url.username = auth.username
+    url.password = auth.password
+  }
+
+  debug('created URL:', url)
+
+  return url
+}

package/src/utils/isObject.test.ts

@@ -0,0 +1,19 @@
+import { isObject } from './isObject'
+
+test('resolves given an object', () => {
+  expect(isObject({})).toBe(true)
+  expect(isObject({ a: 1 })).toBe(true)
+})
+
+test('rejects given an object-like instance', () => {
+  expect(isObject([1])).toBe(false)
+  expect(isObject(function () {})).toBe(false)
+})
+
+test('rejects given a non-object instance', () => {
+  expect(isObject(null)).toBe(false)
+  expect(isObject(undefined)).toBe(false)
+  expect(isObject(false)).toBe(false)
+  expect(isObject(123)).toBe(false)
+  expect(isObject(Symbol('object Object'))).toBe(false)
+})

package/src/utils/isObject.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines if a given value is an instance of object.
+ */
+export function isObject(value: any): boolean {
+  return Object.prototype.toString.call(value) === '[object Object]'
+}

package/src/utils/parseJson.test.ts

@@ -0,0 +1,9 @@
+import { parseJson } from './parseJson'
+
+test('parses a given string into JSON', () => {
+  expect(parseJson('{"id":1}')).toEqual({ id: 1 })
+})
+
+test('returns null given invalid JSON string', () => {
+  expect(parseJson('{"o:2\'')).toBeNull()
+})

package/src/utils/parseJson.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses a given string into JSON.
+ * Gracefully handles invalid JSON by returning `null`.
+ */
+export function parseJson(data: string): Record<string, any> | null {
+  try {
+    const json = JSON.parse(data)
+    return json
+  } catch (_) {
+    return null
+  }
+}

package/src/utils/toIsoResponse.test.ts

@@ -0,0 +1,39 @@
+import { Headers } from 'headers-utils'
+import { toIsoResponse } from './toIsoResponse'
+
+test('returns a well-formed empty response', () => {
+  expect(toIsoResponse({})).toEqual({
+    status: 200,
+    statusText: 'OK',
+    headers: new Headers(),
+  })
+})
+
+test('uses fallback values for the missing response properties', () => {
+  expect(toIsoResponse({ status: 301, body: 'text-body' })).toEqual({
+    status: 301,
+    statusText: 'OK',
+    headers: new Headers(),
+    body: 'text-body',
+  })
+})
+
+test('returns a full response as-is, converting the headers', () => {
+  expect(
+    toIsoResponse({
+      status: 301,
+      statusText: 'Custom Status',
+      headers: {
+        'X-Allowed': 'yes',
+      },
+      body: 'text-body',
+    })
+  ).toEqual({
+    status: 301,
+    statusText: 'Custom Status',
+    headers: new Headers({
+      'X-Allowed': 'yes',
+    }),
+    body: 'text-body',
+  })
+})

package/src/utils/toIsoResponse.ts

@@ -0,0 +1,14 @@
+import { objectToHeaders } from 'headers-utils'
+import { IsomorphicResponse, MockedResponse } from '../createInterceptor'
+
+/**
+ * Converts a given mocked response object into an isomorphic response.
+ */
+export function toIsoResponse(response: MockedResponse): IsomorphicResponse {
+  return {
+    status: response.status || 200,
+    statusText: response.statusText || 'OK',
+    headers: objectToHeaders(response.headers || {}),
+    body: response.body,
+  }
+}

package/src/utils/uuid.ts

@@ -0,0 +1,7 @@
+export function uuidv4(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    const r = (Math.random() * 16) | 0
+    const v = c == 'x' ? r : (r & 0x3) | 0x8
+    return v.toString(16)
+  })
+}