Function JestChaiExpect

packages/expect/src/jest-expect.ts:38–1216

(chai, utils)

// Jest Expect Compact
export const JestChaiExpect: ChaiPlugin = (chai, utils) => {
  const { AssertionError } = chai
  const customTesters = getCustomEqualityTesters()

  function def(
    name: keyof Assertion | (keyof Assertion)[],
    fn: (this: Chai.AssertionStatic & Assertion, ...args: any[]) => any,
  ) {
    const addMethod = (n: keyof Assertion) => {
      const softWrapper = wrapAssertion(utils, n, fn)
      utils.addMethod(chai.Assertion.prototype, n, softWrapper)
      utils.addMethod(
        (globalThis as any)[JEST_MATCHERS_OBJECT].matchers,
        n,
        softWrapper,
      )
    }

    if (Array.isArray(name)) {
      name.forEach(n => addMethod(n))
    }
    else {
      addMethod(name)
    }
  }

  (['throw', 'throws', 'Throw'] as const).forEach((m) => {
    utils.overwriteMethod(chai.Assertion.prototype, m, (_super: any) => {
      return function (
        this: Chai.Assertion & Chai.AssertionStatic,
        ...args: any[]
      ) {
        const promise = utils.flag(this, 'promise')
        const object = utils.flag(this, 'object')
        const isNot = utils.flag(this, 'negate') as boolean
        if (promise === 'rejects') {
          utils.flag(this, 'object', () => {
            throw object
          })
        }
        // if it got here, it's already resolved
        // unless it tries to resolve to a function that should throw
        // called as '.resolves[.not].toThrow()`
        else if (promise === 'resolves' && typeof object !== 'function') {
          if (!isNot) {
            const message
              = utils.flag(this, 'message')
                || 'expected promise to throw an error, but it didn\'t'
            const error = {
              showDiff: false,
            }
            throw new AssertionError(message, error, utils.flag(this, 'ssfi'))
          }
          else {
            return
          }
        }
        _super.apply(this, args)