Viewing github.com/facebook/react/scripts/jest/setupTests.js

```
'use strict';
```
```
const chalk = require('chalk');
```
```
const util = require('util');
```

const shouldIgnoreConsoleError = require('./shouldIgnoreConsoleError');

const {getTestFlags} = require('./TestFlags');

if (process.env.REACT_CLASS_EQUIVALENCE_TEST) {

  // Inside the class equivalence tester, we have a custom environment, let's

```
  // require that instead.
```

  require('./spec-equivalence-reporter/setupTests.js');

```
} else {
```

  const errorMap = require('../error-codes/codes.json');

  // By default, jest.spyOn also calls the spied method.

```
  const spyOn = jest.spyOn;
```
```
  const noop = jest.fn;
```

  // Spying on console methods in production builds can mask errors.

  // This is why we added an explicit spyOnDev() helper.

  // It's too easy to accidentally use the more familiar spyOn() helper though,

```
  // So we disable it entirely.
```

  // Spying on both dev and prod will require using both spyOnDev() and spyOnProd().

```
  global.spyOn = function () {
```
```
    throw new Error(
```
```
      'Do not use spyOn(). ' +
```

        'It can accidentally hide unexpected errors in production builds. ' +

        'Use spyOnDev(), spyOnProd(), or spyOnDevAndProd() instead.'

```
    );
```
```
  };
```

  if (process.env.NODE_ENV === 'production') {

```
    global.spyOnDev = noop;
```
```
    global.spyOnProd = spyOn;
```
```
    global.spyOnDevAndProd = spyOn;
```
```
  } else {
```
```
    global.spyOnDev = spyOn;
```
```
    global.spyOnProd = noop;
```
```
    global.spyOnDevAndProd = spyOn;
```
```
  }
```
```
  expect.extend({
```

    ...require('./matchers/reactTestMatchers'),

```
    ...require('./matchers/toThrow'),
```

    ...require('./matchers/toWarnDev'),

```
  });
```

  // We have a Babel transform that inserts guards against infinite loops.

  // If a loop runs for too many iterations, we throw an error and set this

  // global variable. The global lets us detect an infinite loop even if

  // the actual error object ends up being caught and ignored. An infinite

```
  // loop must always fail the test!
```
```
  beforeEach(() => {
```
```
    global.infiniteLoopError = null;
```
```
  });
```
```
  afterEach(() => {
```

    const error = global.infiniteLoopError;

```
    global.infiniteLoopError = null;
```
```
    if (error) {
```
```
      throw error;
```
```
    }
```
```
  });
```

  // TODO: Consider consolidating this with `yieldValue`. In both cases, tests

  // should not be allowed to exit without asserting on the entire log.

  const patchConsoleMethod = (methodName, unexpectedConsoleCallStacks) => {

    const newMethod = function (format, ...args) {

      // Ignore uncaught errors reported by jsdom

      // and React addendums because they're too noisy.

      if (methodName === 'error' && shouldIgnoreConsoleError(format, args)) {

```
        return;
```
```
      }
```

      // Capture the call stack now so we can warn about it later.

      // The call stack has helpful information for the test author.

      // Don't throw yet though b'c it might be accidentally caught and suppressed.

```
      const stack = new Error().stack;
```

      unexpectedConsoleCallStacks.push([

        stack.slice(stack.indexOf('\n') + 1),

```
        util.format(format, ...args),
```
```
      ]);
```
```
    };
```
```
    console[methodName] = newMethod;
```
```
    return newMethod;
```
```
  };
```

  const flushUnexpectedConsoleCalls = (

```
    mockMethod,
```
```
    methodName,
```
```
    expectedMatcher,
```
```
    unexpectedConsoleCallStacks
```
```
  ) => {
```
```
    if (
```

      console[methodName] !== mockMethod &&

      !jest.isMockFunction(console[methodName])

```
    ) {
```
```
      throw new Error(
```

        `Test did not tear down console.${methodName} mock properly.`

```
      );
```
```
    }
```

    if (unexpectedConsoleCallStacks.length > 0) {

      const messages = unexpectedConsoleCallStacks.map(

```
        ([stack, message]) =>
```
```
          `${chalk.red(message)}\n` +
```
```
          `${stack
```
```
            .split('\n')
```

            .map(line => chalk.gray(line))

```
            .join('\n')}`
```
```
      );
```
```
      const message =
```

        `Expected test not to call ${chalk.bold(

```
          `console.${methodName}()`
```
```
        )}.\n\n` +
```

        'If the warning is expected, test for it explicitly by:\n' +

        `1. Using the ${chalk.bold('.' + expectedMatcher + '()')} ` +

```
        `matcher, or...\n` +
```

        `2. Mock it out using ${chalk.bold(

```
          'spyOnDev'
```

        )}(console, '${methodName}') or ${chalk.bold(

```
          'spyOnProd'
```

        )}(console, '${methodName}'), and test that the warning occurs.`;

      throw new Error(`${message}\n\n${messages.join('\n\n')}`);

```
    }
```
```
  };
```

  const unexpectedErrorCallStacks = [];

```
  const unexpectedWarnCallStacks = [];
```

  const errorMethod = patchConsoleMethod('error', unexpectedErrorCallStacks);

  const warnMethod = patchConsoleMethod('warn', unexpectedWarnCallStacks);

  const flushAllUnexpectedConsoleCalls = () => {

```
    flushUnexpectedConsoleCalls(
```
```
      errorMethod,
```
```
      'error',
```
```
      'toErrorDev',
```
```
      unexpectedErrorCallStacks
```
```
    );
```
```
    flushUnexpectedConsoleCalls(
```
```
      warnMethod,
```
```
      'warn',
```
```
      'toWarnDev',
```
```
      unexpectedWarnCallStacks
```
```
    );
```

    unexpectedErrorCallStacks.length = 0;

    unexpectedWarnCallStacks.length = 0;

```
  };
```

  const resetAllUnexpectedConsoleCalls = () => {

    unexpectedErrorCallStacks.length = 0;

    unexpectedWarnCallStacks.length = 0;

```
  };
```

  beforeEach(resetAllUnexpectedConsoleCalls);

  afterEach(flushAllUnexpectedConsoleCalls);

  if (process.env.NODE_ENV === 'production') {

    // In production, we strip error messages and turn them into codes.

    // This decodes them back so that the test assertions on them work.

    // 1. `ErrorProxy` decodes error messages at Error construction time and

    //    also proxies error instances with `proxyErrorInstance`.

    // 2. `proxyErrorInstance` decodes error messages when the `message`

```
    //    property is changed.
```

    const decodeErrorMessage = function (message) {

```
      if (!message) {
```
```
        return message;
```
```
      }
```

      const re = /error-decoder.html\?invariant=(\d+)([^\s]*)/;

      const matches = message.match(re);

      if (!matches || matches.length !== 3) {

```
        return message;
```
```
      }
```

      const code = parseInt(matches[1], 10);

```
      const args = matches[2]
```
```
        .split('&')
```

        .filter(s => s.startsWith('args[]='))

        .map(s => s.slice('args[]='.length))

```
        .map(decodeURIComponent);
```
```
      const format = errorMap[code];
```
```
      let argIndex = 0;
```

      return format.replace(/%s/g, () => args[argIndex++]);

```
    };
```

    const OriginalError = global.Error;

    // V8's Error.captureStackTrace (used in Jest) fails if the error object is

    // a Proxy, so we need to pass it the unproxied instance.

    const originalErrorInstances = new WeakMap();

    const captureStackTrace = function (error, ...args) {

      return OriginalError.captureStackTrace.call(

```
        this,
```

        originalErrorInstances.get(error) ||

          // Sometimes this wrapper receives an already-unproxied instance.

```
          error,
```
```
        ...args
```
```
      );
```
```
    };
```

    const proxyErrorInstance = error => {

```
      const proxy = new Proxy(error, {
```

        set(target, key, value, receiver) {

```
          if (key === 'message') {
```
```
            return Reflect.set(
```
```
              target,
```
```
              key,
```

              decodeErrorMessage(value),

```
              receiver
```
```
            );
```
```
          }
```

          return Reflect.set(target, key, value, receiver);

```
        },
```
```
      });
```

      originalErrorInstances.set(proxy, error);

```
      return proxy;
```
```
    };
```

    const ErrorProxy = new Proxy(OriginalError, {

      apply(target, thisArg, argumentsList) {

        const error = Reflect.apply(target, thisArg, argumentsList);

        error.message = decodeErrorMessage(error.message);

        return proxyErrorInstance(error);

```
      },
```

      construct(target, argumentsList, newTarget) {

        const error = Reflect.construct(target, argumentsList, newTarget);

        error.message = decodeErrorMessage(error.message);

        return proxyErrorInstance(error);

```
      },
```
```
      get(target, key, receiver) {
```

        if (key === 'captureStackTrace') {

```
          return captureStackTrace;
```
```
        }
```

        return Reflect.get(target, key, receiver);

```
      },
```
```
    });
```

    ErrorProxy.OriginalError = OriginalError;

```
    global.Error = ErrorProxy;
```
```
  }
```

  const expectTestToFail = async (callback, errorMsg) => {

```
    if (callback.length > 0) {
```
```
      throw Error(
```

        'Gated test helpers do not support the `done` callback. Return a ' +

```
          'promise instead.'
```
```
      );
```
```
    }
```
```
    try {
```
```
      const maybePromise = callback();
```
```
      if (
```
```
        maybePromise !== undefined &&
```
```
        maybePromise !== null &&
```

        typeof maybePromise.then === 'function'

```
      ) {
```
```
        await maybePromise;
```
```
      }
```

      // Flush unexpected console calls inside the test itself, instead of in

      // `afterEach` like we normally do. `afterEach` is too late because if it

      // throws, we won't have captured it.

      flushAllUnexpectedConsoleCalls();

```
    } catch (error) {
```
```
      // Failed as expected
```

      resetAllUnexpectedConsoleCalls();

```
      return;
```
```
    }
```
```
    throw Error(errorMsg);
```
```
  };
```

  const gatedErrorMessage = 'Gated test was expected to fail, but it passed.';

  global._test_gate = (gateFn, testName, callback) => {

```
    let shouldPass;
```
```
    try {
```
```
      const flags = getTestFlags();
```
```
      shouldPass = gateFn(flags);
```
```
    } catch (e) {
```
```
      test(testName, () => {
```
```
        throw e;
```
```
      });
```
```
      return;
```
```
    }
```
```
    if (shouldPass) {
```
```
      test(testName, callback);
```
```
    } else {
```

      test(`[GATED, SHOULD FAIL] ${testName}`, () =>

        expectTestToFail(callback, gatedErrorMessage));

```
    }
```
```
  };
```

  global._test_gate_focus = (gateFn, testName, callback) => {

```
    let shouldPass;
```
```
    try {
```
```
      const flags = getTestFlags();
```
```
      shouldPass = gateFn(flags);
```
```
    } catch (e) {
```
```
      test.only(testName, () => {
```
```
        throw e;
```
```
      });
```
```
      return;
```
```
    }
```
```
    if (shouldPass) {
```
```
      test.only(testName, callback);
```
```
    } else {
```

      test.only(`[GATED, SHOULD FAIL] ${testName}`, () =>

        expectTestToFail(callback, gatedErrorMessage));

```
    }
```
```
  };
```
```
  // Dynamic version of @gate pragma
```
```
  global.gate = fn => {
```
```
    const flags = getTestFlags();
```
```
    return fn(flags);
```
```
  };
```
```
}
```