@jest-mock/express/src/test/response/provided/provided.event.EventEmitter.test.ts

A lightweight Jest mock for unit testing Express

// Helpers
import { providedFunction } from '../../helpers/provided'

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

describe('response - Provided for "event.EventEmitter" (accepts arguments and returns expected values)', () => {
  test('res.addListener can be provided', () => {
    const { res } = getMockRes({ addListener: providedFunction })

    expect(res.addListener).toBeDefined()
    expect(res.addListener).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.removeListener can be provided', () => {
    const { res } = getMockRes({ removeListener: providedFunction })

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    expect(res.listenerCount).toBeDefined()
    expect(res.listenerCount).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.eventNames can be provided', () => {
    const { res } = getMockRes({ eventNames: providedFunction })

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