@jest-mock/express/src/test/response/provided/provided.stream.Writable.test.ts

A lightweight Jest mock for unit testing Express

// Helpers
import { providedFunction, providedNumber, providedBoolean } from '../../helpers/provided'

// Tested Module
import getMockRes from '../../../response/response'

describe('response - Provided for "stream.Writable" (accepts arguments and returns expected values)', () => {
  test('res.writable can be provided', () => {
    const { res } = getMockRes({ writable: providedBoolean })

    expect(res.writable).toBeDefined()
    expect(res.writable).toBe(providedBoolean)
  })

  test('res.writableEnded can be provided', () => {
    const { res } = getMockRes({ writableEnded: providedBoolean })

    expect(res.writableEnded).toBeDefined()
    expect(res.writableEnded).toBe(providedBoolean)
  })

  test('res.writableFinished can be provided', () => {
    const { res } = getMockRes({ writableFinished: providedBoolean })

    expect(res.writableFinished).toBeDefined()
    expect(res.writableFinished).toBe(providedBoolean)
  })

  test('res.writableHighWaterMark can be provided', () => {
    const { res } = getMockRes({ writableHighWaterMark: providedNumber })

    expect(res.writableHighWaterMark).toBeDefined()
    expect(res.writableHighWaterMark).toBe(providedNumber)
  })

  test('res.writableLength can be provided', () => {
    const { res } = getMockRes({ writableLength: providedNumber })

    expect(res.writableLength).toBeDefined()
    expect(res.writableLength).toBe(providedNumber)
  })

  test('res.writableObjectMode can be provided', () => {
    const { res } = getMockRes({ writableObjectMode: providedBoolean })

    expect(res.writableObjectMode).toBeDefined()
    expect(res.writableObjectMode).toBe(providedBoolean)
  })

  test('res.writableCorked can be provided', () => {
    const { res } = getMockRes({ writableCorked: providedNumber })

    expect(res.writableCorked).toBeDefined()
    expect(res.writableCorked).toBe(providedNumber)
  })

  test('res.destroyed can be provided', () => {
    const { res } = getMockRes({ destroyed: providedBoolean })

    expect(res.destroyed).toBeDefined()
    expect(res.destroyed).toBe(providedBoolean)
  })

  test('res._write can be provided', () => {
    const { res } = getMockRes({ _write: providedFunction })

    expect(res._write).toBeDefined()
    expect(res._write).toBe(providedFunction)
  })

  test('res._writev can be provided', () => {
    const { res } = getMockRes({ _writev: providedFunction })

    expect(res._writev).toBeDefined()
    expect(res._writev).toBe(providedFunction)
  })

  test('res._destroy can be provided', () => {
    const { res } = getMockRes({ _destroy: providedFunction })

    expect(res._destroy).toBeDefined()
    expect(res._destroy).toBe(providedFunction)
  })

  test('res._final can be provided', () => {
    const { res } = getMockRes({ _final: providedFunction })

    expect(res._final).toBeDefined()
    expect(res._final).toBe(providedFunction)
  })

  test('res.write can be provided', () => {
    const { res } = getMockRes({ write: providedFunction })

    expect(res.write).toBeDefined()
    expect(res.write).toBe(providedFunction)
  })

  test('res.setDefaultEncoding can be provided', () => {
    const { res } = getMockRes({ setDefaultEncoding: providedFunction })

    expect(res.setDefaultEncoding).toBeDefined()
    expect(res.setDefaultEncoding).toBe(providedFunction)
  })

  test('res.end can be provided', () => {
    const { res } = getMockRes({ end: providedFunction })

    expect(res.end).toBeDefined()
    expect(res.end).toBe(providedFunction)
  })

  test('res.cork can be provided', () => {
    const { res } = getMockRes({ cork: providedFunction })

    expect(res.cork).toBeDefined()
    expect(res.cork).toBe(providedFunction)
  })

  test('res.uncork can be provided', () => {
    const { res } = getMockRes({ uncork: providedFunction })

    expect(res.uncork).toBeDefined()
    expect(res.uncork).toBe(providedFunction)
  })

  test('res.destroy can be provided', () => {
    const { res } = getMockRes({ destroy: providedFunction })

    expect(res.destroy).toBeDefined()
    expect(res.destroy).toBe(providedFunction)
  })

  test('res.addListener can be provided', () => {
    const { res } = getMockRes({ addListener: providedFunction })

    expect(res.addListener).toBeDefined()
    expect(res.addListener).toBe(providedFunction)
  })

  test('res.emit can be provided', () => {
    const { res } = getMockRes({ emit: providedFunction })

    expect(res.emit).toBeDefined()
    expect(res.emit).toBe(providedFunction)
  })

  test('res.on can be provided', () => {
    const { res } = getMockRes({ on: providedFunction })

    expect(res.on).toBeDefined()
    expect(res.on).toBe(providedFunction)
  })

  test('res.once can be provided', () => {
    const { res } = getMockRes({ once: providedFunction })

    expect(res.once).toBeDefined()
    expect(res.once).toBe(providedFunction)
  })

  test('res.prependListener can be provided', () => {
    const { res } = getMockRes({ prependListener: providedFunction })

    expect(res.prependListener).toBeDefined()
    expect(res.prependListener).toBe(providedFunction)
  })

  test('res.prependOnceListener can be provided', () => {
    const { res } = getMockRes({ prependOnceListener: providedFunction })

    expect(res.prependOnceListener).toBeDefined()
    expect(res.prependOnceListener).toBe(providedFunction)
  })

  test('res.removeListener can be provided', () => {
    const { res } = getMockRes({ removeListener: providedFunction })

    expect(res.removeListener).toBeDefined()
    expect(res.removeListener).toBe(providedFunction)
  })
})