@mswjs/interceptors 0.31.1 → 0.32.1

package/src/interceptors/Socket/MockSocket.test.ts

@@ -0,0 +1,264 @@
+/**
+ * @vitest-environment node
+ */
+import { Socket } from 'node:net'
+import { vi, it, expect } from 'vitest'
+import { MockSocket } from './MockSocket'
+
+it(`keeps the socket connecting until it's destroyed`, () => {
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: vi.fn(),
+  })
+
+  expect(socket.connecting).toBe(true)
+
+  socket.destroy()
+  expect(socket.connecting).toBe(false)
+})
+
+it('calls the "write" on "socket.write()"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.write()
+  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
+})
+
+it('calls the "write" on "socket.write(chunk)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.write('hello')
+  expect(writeCallback).toHaveBeenCalledWith('hello', undefined, undefined)
+})
+
+it('calls the "write" on "socket.write(chunk, encoding)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.write('hello', 'utf8')
+  expect(writeCallback).toHaveBeenCalledWith('hello', 'utf8', undefined)
+})
+
+it('calls the "write" on "socket.write(chunk, encoding, callback)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  const callback = vi.fn()
+  socket.write('hello', 'utf8', callback)
+  expect(writeCallback).toHaveBeenCalledWith('hello', 'utf8', callback)
+})
+
+it('calls the "write" on "socket.end()"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.end()
+  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
+})
+
+it('calls the "write" on "socket.end(chunk)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.end('final')
+  expect(writeCallback).toHaveBeenCalledWith('final', undefined, undefined)
+})
+
+it('calls the "write" on "socket.end(chunk, encoding)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.end('final', 'utf8')
+  expect(writeCallback).toHaveBeenCalledWith('final', 'utf8', undefined)
+})
+
+it('calls the "write" on "socket.end(chunk, encoding, callback)"', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  const callback = vi.fn()
+  socket.end('final', 'utf8', callback)
+  expect(writeCallback).toHaveBeenCalledWith('final', 'utf8', callback)
+})
+
+it('calls the "write" on "socket.end()" without any arguments', () => {
+  const writeCallback = vi.fn()
+  const socket = new MockSocket({
+    write: writeCallback,
+    read: vi.fn(),
+  })
+
+  socket.end()
+  expect(writeCallback).toHaveBeenCalledWith(undefined, undefined, undefined)
+})
+
+it('emits "finished" on .end() without any arguments', async () => {
+  const finishListener = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: vi.fn(),
+  })
+  socket.on('finish', finishListener)
+  socket.end()
+
+  await vi.waitFor(() => {
+    expect(finishListener).toHaveBeenCalledTimes(1)
+  })
+})
+
+it('calls the "read" on "socket.read(chunk)"', () => {
+  const readCallback = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: readCallback,
+  })
+
+  socket.push('hello')
+  expect(readCallback).toHaveBeenCalledWith('hello', undefined)
+})
+
+it('calls the "read" on "socket.read(chunk, encoding)"', () => {
+  const readCallback = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: readCallback,
+  })
+
+  socket.push('world', 'utf8')
+  expect(readCallback).toHaveBeenCalledWith('world', 'utf8')
+})
+
+it('calls the "read" on "socket.read(null)"', () => {
+  const readCallback = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: readCallback,
+  })
+
+  socket.push(null)
+  expect(readCallback).toHaveBeenCalledWith(null, undefined)
+})
+
+it('updates the writable state on "socket.end()"', async () => {
+  const finishListener = vi.fn()
+  const endListener = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: vi.fn(),
+  })
+  socket.on('finish', finishListener)
+  socket.on('end', endListener)
+
+  expect(socket.writable).toBe(true)
+  expect(socket.writableEnded).toBe(false)
+  expect(socket.writableFinished).toBe(false)
+
+  socket.write('hello')
+  // Finish the writable stream.
+  socket.end()
+
+  expect(socket.writable).toBe(false)
+  expect(socket.writableEnded).toBe(true)
+
+  // The "finish" event is emitted when writable is done.
+  // I.e. "socket.end()" is called.
+  await vi.waitFor(() => {
+    expect(finishListener).toHaveBeenCalledTimes(1)
+  })
+  expect(socket.writableFinished).toBe(true)
+})
+
+it('updates the readable state on "socket.push(null)"', async () => {
+  const endListener = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: vi.fn(),
+  })
+  socket.on('end', endListener)
+
+  expect(socket.readable).toBe(true)
+  expect(socket.readableEnded).toBe(false)
+
+  socket.push('hello')
+  socket.push(null)
+
+  expect(socket.readable).toBe(true)
+  expect(socket.readableEnded).toBe(false)
+
+  // Read the data to free the buffer and
+  // make Socket emit "end".
+  socket.read()
+
+  await vi.waitFor(() => {
+    expect(endListener).toHaveBeenCalledTimes(1)
+  })
+  expect(socket.readable).toBe(false)
+  expect(socket.readableEnded).toBe(true)
+})
+
+it('updates the readable/writable state on "socket.destroy()"', async () => {
+  const finishListener = vi.fn()
+  const endListener = vi.fn()
+  const closeListener = vi.fn()
+  const socket = new MockSocket({
+    write: vi.fn(),
+    read: vi.fn(),
+  })
+  socket.on('finish', finishListener)
+  socket.on('end', endListener)
+  socket.on('close', closeListener)
+
+  expect(socket.writable).toBe(true)
+  expect(socket.writableEnded).toBe(false)
+  expect(socket.writableFinished).toBe(false)
+  expect(socket.readable).toBe(true)
+
+  socket.destroy()
+
+  expect(socket.writable).toBe(false)
+  // The ".end()" wasn't called.
+  expect(socket.writableEnded).toBe(false)
+  expect(socket.writableFinished).toBe(false)
+  expect(socket.readable).toBe(false)
+
+  await vi.waitFor(() => {
+    expect(closeListener).toHaveBeenCalledTimes(1)
+  })
+
+  // Neither "finish" nor "end" events are emitted
+  // when you destroy the stream. If you want those,
+  // call ".end()", then destroy the stream.
+  expect(finishListener).not.toHaveBeenCalled()
+  expect(endListener).not.toHaveBeenCalled()
+  expect(socket.writableFinished).toBe(false)
+
+  // The "end" event was never emitted so "readableEnded"
+  // remains false.
+  expect(socket.readableEnded).toBe(false)
+})

package/src/interceptors/Socket/MockSocket.ts

@@ -0,0 +1,59 @@
+import net from 'node:net'
+import {
+  normalizeSocketWriteArgs,
+  type WriteArgs,
+  type WriteCallback,
+} from './utils/normalizeSocketWriteArgs'
+
+export interface MockSocketOptions {
+  write: (
+    chunk: Buffer | string,
+    encoding: BufferEncoding | undefined,
+    callback?: WriteCallback
+  ) => void
+
+  read: (chunk: Buffer, encoding: BufferEncoding | undefined) => void
+}
+
+export class MockSocket extends net.Socket {
+  public connecting: boolean
+
+  constructor(protected readonly options: MockSocketOptions) {
+    super()
+    this.connecting = false
+    this.connect()
+
+    this._final = (callback) => {
+      callback(null)
+    }
+  }
+
+  public connect() {
+    // The connection will remain pending until
+    // the consumer decides to handle it.
+    this.connecting = true
+    return this
+  }
+
+  public write(...args: Array<unknown>): boolean {
+    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
+      args as WriteArgs
+    )
+    this.options.write(chunk, encoding, callback)
+    return true
+  }
+
+  public end(...args: Array<unknown>) {
+    const [chunk, encoding, callback] = normalizeSocketWriteArgs(
+      args as WriteArgs
+    )
+    this.options.write(chunk, encoding, callback)
+
+    return super.end.apply(this, args as any)
+  }
+
+  public push(chunk: any, encoding?: BufferEncoding): boolean {
+    this.options.read(chunk, encoding)
+    return super.push(chunk, encoding)
+  }
+}

package/src/interceptors/Socket/utils/baseUrlFromConnectionOptions.ts

@@ -0,0 +1,26 @@
+export function baseUrlFromConnectionOptions(options: any): URL {
+  if ('href' in options) {
+    return new URL(options.href)
+  }
+
+  const protocol = options.port === 443 ? 'https:' : 'http:'
+  const host = options.host
+
+  const url = new URL(`${protocol}//${host}`)
+
+  if (options.port) {
+    url.port = options.port.toString()
+  }
+
+  if (options.path) {
+    url.pathname = options.path
+  }
+
+  if (options.auth) {
+    const [username, password] = options.auth.split(':')
+    url.username = username
+    url.password = password
+  }
+
+  return url
+}

package/src/interceptors/Socket/utils/normalizeSocketWriteArgs.test.ts

@@ -0,0 +1,52 @@
+/**
+ * @vitest-environment node
+ */
+import { it, expect } from 'vitest'
+import { normalizeSocketWriteArgs } from './normalizeSocketWriteArgs'
+
+it('normalizes .write()', () => {
+  expect(normalizeSocketWriteArgs([undefined])).toEqual([
+    undefined,
+    undefined,
+    undefined,
+  ])
+  expect(normalizeSocketWriteArgs([null])).toEqual([null, undefined, undefined])
+})
+
+it('normalizes .write(chunk)', () => {
+  expect(normalizeSocketWriteArgs([Buffer.from('hello')])).toEqual([
+    Buffer.from('hello'),
+    undefined,
+    undefined,
+  ])
+  expect(normalizeSocketWriteArgs(['hello'])).toEqual([
+    'hello',
+    undefined,
+    undefined,
+  ])
+  expect(normalizeSocketWriteArgs([null])).toEqual([null, undefined, undefined])
+})
+
+it('normalizes .write(chunk, encoding)', () => {
+  expect(normalizeSocketWriteArgs([Buffer.from('hello'), 'utf8'])).toEqual([
+    Buffer.from('hello'),
+    'utf8',
+    undefined,
+  ])
+})
+
+it('normalizes .write(chunk, callback)', () => {
+  const callback = () => {}
+  expect(normalizeSocketWriteArgs([Buffer.from('hello'), callback])).toEqual([
+    Buffer.from('hello'),
+    undefined,
+    callback,
+  ])
+})
+
+it('normalizes .write(chunk, encoding, callback)', () => {
+  const callback = () => {}
+  expect(
+    normalizeSocketWriteArgs([Buffer.from('hello'), 'utf8', callback])
+  ).toEqual([Buffer.from('hello'), 'utf8', callback])
+})

package/src/interceptors/Socket/utils/normalizeSocketWriteArgs.ts

@@ -0,0 +1,33 @@
+export type WriteCallback = (error?: Error | null) => void
+
+export type WriteArgs =
+  | [chunk: unknown, callback?: WriteCallback]
+  | [chunk: unknown, encoding: BufferEncoding, callback?: WriteCallback]
+
+export type NormalizedSocketWriteArgs = [
+  chunk: any,
+  encoding?: BufferEncoding,
+  callback?: WriteCallback,
+]
+
+/**
+ * Normalizes the arguments provided to the `Writable.prototype.write()`
+ * and `Writable.prototype.end()`.
+ */
+export function normalizeSocketWriteArgs(
+  args: WriteArgs
+): NormalizedSocketWriteArgs {
+  const normalized: NormalizedSocketWriteArgs = [args[0], undefined, undefined]
+
+  if (typeof args[1] === 'string') {
+    normalized[1] = args[1]
+  } else if (typeof args[1] === 'function') {
+    normalized[2] = args[1]
+  }
+
+  if (typeof args[2] === 'function') {
+    normalized[2] = args[2]
+  }
+
+  return normalized
+}

package/src/interceptors/Socket/utils/parseRawHeaders.ts

@@ -0,0 +1,10 @@
+/**
+ * Create a Fetch API `Headers` instance from the given raw headers list.
+ */
+export function parseRawHeaders(rawHeaders: Array<string>): Headers {
+  const headers = new Headers()
+  for (let line = 0; line < rawHeaders.length; line += 2) {
+    headers.append(rawHeaders[line], rawHeaders[line + 1])
+  }
+  return headers
+}