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

A lightweight Jest mock for unit testing Express

// Helpers
import {
  providedApp,
  providedBoolean,
  providedFunction,
  providedObject,
  providedReq,
  providedString,
} from '../../helpers/provided'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    expect(res.locals).toBeDefined()
    expect(res.locals).toBe(providedObject)
  })

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

    expect(res.charset).toBeDefined()
    expect(res.charset).toBe(providedString)
  })

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

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

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

    expect(res.app).toBeDefined()
    expect(res.app).toBe(providedApp)
  })

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

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

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

    expect(res.req).toBeDefined()
    expect(res.req).toBe(providedReq)
  })
})