@mswjs/interceptors 0.22.2 → 0.22.4

package/src/utils/createProxy.test.ts

@@ -0,0 +1,149 @@
+import { vi, it, expect } from 'vitest'
+import { createProxy } from './createProxy'
+
+it('does not interfere with default constructors', () => {
+  const ProxyClass = createProxy(
+    class {
+      constructor(public name: string) {}
+    },
+    {}
+  )
+
+  const instance = new ProxyClass('John')
+  expect(instance.name).toBe('John')
+})
+
+it('does not interfere with default getters', () => {
+  const proxy = createProxy({ foo: 'initial' }, {})
+  expect(proxy.foo).toBe('initial')
+})
+
+it('does not interfere with default setters', () => {
+  const proxy = createProxy({ foo: 'initial' }, {})
+  proxy.foo = 'next'
+
+  expect(proxy.foo).toBe('next')
+})
+
+it('does not interfere with default methods', () => {
+  const proxy = createProxy({ getValue: () => 'initial' }, {})
+  expect(proxy.getValue()).toBe('initial')
+})
+
+it('does not interfere with existing descriptors', () => {
+  const target = {} as { foo: string; bar: number }
+  let internalBar = 0
+
+  Object.defineProperties(target, {
+    foo: {
+      get: () => 'initial',
+    },
+    bar: {
+      set: (value) => {
+        internalBar = value + 10
+      },
+    },
+  })
+
+  const proxy = createProxy(target, {
+    getProperty(data, next) {
+      return next()
+    },
+  })
+  expect(proxy.foo).toBe('initial')
+
+  proxy.bar = 5
+  expect(proxy.bar).toBeUndefined()
+  expect(internalBar).toBe(15)
+})
+
+it('infer prototype descriptors', () => {
+  class Child {
+    ok: boolean
+
+    set status(nextStatus: number) {
+      this.ok = nextStatus >= 200 && nextStatus < 300
+    }
+  }
+
+  Object.defineProperties(Child.prototype, {
+    status: { enumerable: true },
+  })
+
+  const scope = {} as { child: typeof Child }
+
+  Object.defineProperty(scope, 'child', {
+    enumerable: true,
+    value: Child,
+  })
+
+  const ProxyClass = createProxy(scope.child, {})
+  const instance = new ProxyClass()
+
+  instance.status = 201
+  expect(instance.ok).toBe(true)
+})
+
+it('spies on the constructor', () => {
+  const OriginalClass = class {
+    constructor(public name: string, public age: number) {}
+  }
+
+  const constructorCall = vi.fn<
+    [ConstructorParameters<typeof OriginalClass>, Function],
+    typeof OriginalClass
+  >((args, next) => next())
+
+  const ProxyClass = createProxy(OriginalClass, {
+    constructorCall,
+  })
+
+  new ProxyClass('John', 32)
+
+  expect(constructorCall).toHaveBeenCalledTimes(1)
+  expect(constructorCall).toHaveBeenCalledWith(
+    ['John', 32],
+    expect.any(Function)
+  )
+})
+
+it('spies on property getters', () => {
+  const getProperty = vi.fn((args, next) => next())
+  const proxy = createProxy({ foo: 'initial' }, { getProperty })
+
+  proxy.foo
+
+  expect(getProperty).toHaveBeenCalledTimes(1)
+  expect(getProperty).toHaveBeenCalledWith(['foo', proxy], expect.any(Function))
+})
+
+it('spies on property setters', () => {
+  const setProperty = vi.fn((args, next) => next())
+  const proxy = createProxy({ foo: 'initial' }, { setProperty })
+
+  proxy.foo = 'next'
+
+  expect(setProperty).toHaveBeenCalledTimes(1)
+  expect(setProperty).toHaveBeenCalledWith(
+    ['foo', 'next'],
+    expect.any(Function)
+  )
+})
+
+it('spies on method calls', () => {
+  const methodCall = vi.fn((args, next) => next())
+  const proxy = createProxy(
+    {
+      greet: (name: string) => `hello ${name}`,
+    },
+    { methodCall }
+  )
+
+  proxy.greet('Clair')
+
+  expect(methodCall).toHaveBeenCalledTimes(1)
+  expect(methodCall).toHaveBeenCalledWith(
+    ['greet', ['Clair']],
+    expect.any(Function)
+  )
+})

package/src/utils/createProxy.ts

@@ -9,8 +9,8 @@ export interface ProxyOptions<Target extends Record<string, any>> {
 
   setProperty?(
     data: [propertyName: string | symbol, nextValue: unknown],
-    next: NextFunction<void>
-  ): void
+    next: NextFunction<boolean>
+  ): boolean
 
   getProperty?(
     data: [propertyName: string | symbol, receiver: Target],
@@ -25,6 +25,7 @@ export function createProxy<Target extends object>(
   options: ProxyOptions<Target>
 ): Target {
   const proxy = new Proxy(target, optionsToProxyHandler(options))
+
   return proxy
 }
 
@@ -41,11 +42,31 @@ function optionsToProxyHandler<T extends Record<string, any>>(
     }
   }
 
-  if (typeof setProperty !== 'undefined') {
-    handler.set = function (target, propertyName, nextValue, receiver) {
-      const next = () => Reflect.set(target, propertyName, nextValue, receiver)
-      return setProperty.call(target, [propertyName, nextValue], next) as any
+  handler.set = function (target, propertyName, nextValue, receiver) {
+    const next = () => {
+      const ownDescriptors = Reflect.getOwnPropertyDescriptor(
+        target,
+        propertyName
+      )
+
+      if (typeof ownDescriptors?.set !== 'undefined') {
+        ownDescriptors.set.apply(target, [nextValue])
+        return true
+      }
+
+      return Reflect.defineProperty(target, propertyName, {
+        writable: true,
+        enumerable: true,
+        configurable: true,
+        value: nextValue,
+      })
+    }
+
+    if (typeof setProperty !== 'undefined') {
+      return setProperty.call(target, [propertyName, nextValue], next)
     }
+
+    return next()
   }
 
   handler.get = function (target, propertyName, receiver) {

package/src/utils/getUrlByRequestOptions.test.ts

@@ -4,138 +4,132 @@ import { RequestOptions, Agent as HttpsAgent } from 'https'
 import { getUrlByRequestOptions } from './getUrlByRequestOptions'
 
 it('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')
+  expect(
+    getUrlByRequestOptions({
+      protocol: 'https:',
+      host: '127.0.0.1',
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
 })
 
 it('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/')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+      agent: new HttpAgent(),
+    }).href
+  ).toBe('http://127.0.0.1/')
 })
 
 it('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/')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+      agent: new HttpsAgent({
+        port: 3080,
+      }),
+    }).href
+  ).toBe('https://127.0.0.1:3080/')
 })
 
 it('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/')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/',
+    }).href
+  ).toBe('http://127.0.0.1/')
 })
 
 it('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')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      path: '/secure',
+      cert: '<!-- SSL certificate -->',
+    }).href
+  ).toBe('https://127.0.0.1/secure')
 })
 
 it('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')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      port: 443,
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
 })
 
 it('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')
+  expect(
+    getUrlByRequestOptions({
+      host: '127.0.0.1',
+      agent: new HttpsAgent({
+        port: 443,
+      }),
+      path: '/resource',
+    }).href
+  ).toBe('https://127.0.0.1/resource')
 })
 
-it('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/')
+it('respects explicitly provided port', () => {
+  expect(
+    getUrlByRequestOptions({
+      protocol: 'http:',
+      host: '127.0.0.1',
+      port: 4002,
+      path: '/',
+    }).href
+  ).toBe('http://127.0.0.1:4002/')
 })
 
 it('inherits "username" and "password"', () => {
-  const options: RequestOptions = {
+  const url = getUrlByRequestOptions({
     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')
 })
 
 it('resolves hostname to localhost if none provided', () => {
-  const url = getUrlByRequestOptions({})
+  expect(getUrlByRequestOptions({}).hostname).toBe('localhost')
+})
 
-  expect(url).toBeInstanceOf(URL)
-  expect(url).toHaveProperty('protocol', 'http:')
-  expect(url).toHaveProperty('href', 'http://localhost/')
+it('supports "hostname" instead of "host" and "port"', () => {
+  const options: RequestOptions = {
+    protocol: 'https:',
+    hostname: '127.0.0.1:1234',
+    path: '/resource',
+  }
+
+  expect(getUrlByRequestOptions(options).href).toBe(
+    'https://127.0.0.1:1234/resource'
+  )
+})
+
+it('handles IPv6 hostnames', () => {
+  expect(
+    getUrlByRequestOptions({
+      host: '::1',
+      path: '/resource',
+    }).href
+  ).toBe('http://[::1]/resource')
+
+  expect(
+    getUrlByRequestOptions({
+      host: '::1',
+      port: 3001,
+      path: '/resource',
+    }).href
+  ).toBe('http://[::1]:3001/resource')
 })

package/src/utils/getUrlByRequestOptions.ts

@@ -15,7 +15,6 @@ 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(
@@ -45,20 +44,45 @@ function getProtocolByRequestOptions(options: ResolvedRequestOptions): string {
 function getPortByRequestOptions(
   options: ResolvedRequestOptions
 ): number | undefined {
+  // Use the explicitly provided port.
+  if (options.port) {
+    return Number(options.port)
+  }
+
+  // Extract the port from the hostname.
+  if (options.hostname != null) {
+    const [, extractedPort] = options.hostname.match(/:(\d+)$/) || []
+
+    if (extractedPort != null) {
+      return Number(extractedPort)
+    }
+  }
+
+  // Otherwise, try to resolve port from the agent.
   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)
+
+  if ((agent as HttpsAgent)?.options.port) {
+    return Number((agent as HttpsAgent).options.port)
   }
+
+  if ((agent as RequestOptions)?.defaultPort) {
+    return Number((agent as RequestOptions).defaultPort)
+  }
+
+  // Lastly, return undefined indicating that the port
+  // must inferred from the protocol. Do not infer it here.
+  return undefined
 }
 
 function getHostByRequestOptions(options: ResolvedRequestOptions): string {
-  return options.hostname || options.host || DEFAULT_HOST
+  const { hostname, host } = options
+
+  // If the hostname is specified, resolve the host from the "host:port" string.
+  if (hostname != null) {
+    return hostname.replace(/:\d+$/, '')
+  }
+
+  return host || DEFAULT_HOST
 }
 
 function getAuthByRequestOptions(options: ResolvedRequestOptions) {
@@ -77,45 +101,65 @@ function isRawIPv6Address(host: string): boolean {
   return host.includes(':') && !host.startsWith('[') && !host.endsWith(']')
 }
 
+function getHostname(host: string, port?: number): string {
+  const portString = typeof port !== 'undefined' ? `:${port}` : ''
+
+  /**
+   * @note As of Node >= 17, hosts (including "localhost") can resolve to IPv6
+   * addresses, so construct valid URL by surrounding the IPv6 host with brackets.
+   */
+  if (isRawIPv6Address(host)) {
+    return `[${host}]${portString}`
+  }
+
+  if (typeof port === 'undefined') {
+    return host
+  }
+
+  return `${host}${portString}`
+}
+
 /**
  * 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)
+  if (options.uri) {
+    debug(
+      'constructing url from explicitly provided "options.uri": %s',
+      options.uri
+    )
+    return new URL(options.uri.href)
+  }
 
+  debug('figuring out url from request options...')
+
+  const protocol = getProtocolByRequestOptions(options)
   debug('protocol', protocol)
+
+  const host = getHostByRequestOptions(options)
   debug('host', host)
-  debug('port', port)
-  debug('path', path)
 
-  /**
-   * @note As of Node >= 17, hosts (including "localhost") can resolve to IPv6
-   * addresses, so construct valid URL by surrounding the IPv6 host with brackets.
-   */
-  const baseUrl = `${protocol}//${isRawIPv6Address(host) ? `[${host}]` : host}`
-  debug('base URL:', baseUrl)
+  const port = getPortByRequestOptions(options)
+  debug('port', port)
 
-  const url = options.uri ? new URL(options.uri.href) : new URL(path, baseUrl)
+  const hostname = getHostname(host, port)
+  debug('hostname', hostname)
 
-  if (port) {
-    debug('detected explicit port', port)
-    url.port = port.toString()
-  }
+  const path = options.path || DEFAULT_PATH
+  debug('path', path)
 
-  if (auth) {
-    debug('resolved auth', auth)
+  const credentials = getAuthByRequestOptions(options)
+  debug('credentials', credentials)
 
-    url.username = auth.username
-    url.password = auth.password
-  }
+  const authString = credentials
+    ? `${credentials.username}:${credentials.password}@`
+    : ''
+  debug('auth string:', authString)
 
-  debug('created URL:', url)
+  const url = new URL(`${protocol}//${authString}${hostname}${path}`)
+  debug('created url:', url)
 
   return url
 }